@voltr/vault-sdk 1.0.19 → 1.0.21

package/dist/client.js

@@ -263,6 +263,119 @@ class VoltrClient extends AccountUtils {
         const [lpMetadataAccount] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.METADATA, constants_1.METADATA_PROGRAM_ID.toBuffer(), lpMint.toBuffer()], constants_1.METADATA_PROGRAM_ID);
         return lpMetadataAccount;
     }
+    /**
+     * Finds the protocol PDA address
+     * @returns The PDA for the protocol account
+     *
+     * @example
+     * ```typescript
+     * const protocol = client.findProtocol();
+     * ```
+     */
+    findProtocol() {
+        const [protocol] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.PROTOCOL], this.vaultProgram.programId);
+        return protocol;
+    }
+    // --------------------------------------- Protocol Instructions
+    /**
+     * 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,
+     *   }
+     * );
+     * ```
+     */
+    async createInitProtocolIx(operationalState, { payer, admin, }) {
+        return await this.vaultProgram.methods
+            .initProtocol(operationalState)
+            .accounts({
+            payer,
+            admin,
+        })
+            .instruction();
+    }
+    /**
+     * 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 }
+     * );
+     * ```
+     */
+    async createUpdateProtocolIx(field, data, { admin, }) {
+        const fieldToVariant = {
+            [types_1.ProtocolConfigField.OperationalState]: { operationalState: {} },
+            [types_1.ProtocolConfigField.PendingAdmin]: { pendingAdmin: {} },
+        };
+        const fieldVariant = fieldToVariant[field];
+        if (!fieldVariant) {
+            throw new Error(`Unknown protocol config field: ${field}`);
+        }
+        return await this.vaultProgram.methods
+            .updateProtocol(fieldVariant, data)
+            .accounts({
+            admin,
+        })
+            .instruction();
+    }
+    /**
+     * 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,
+     * });
+     * ```
+     */
+    async createAcceptProtocolAdminIx({ pendingAdmin, }) {
+        return await this.vaultProgram.methods
+            .acceptProtocolAdmin()
+            .accounts({
+            pendingAdmin,
+        })
+            .instruction();
+    }
     // --------------------------------------- Vault Instructions
     /**
      * Creates an instruction to initialize a new vault
@@ -610,6 +723,50 @@ class VoltrClient extends AccountUtils {
         })
             .instruction();
     }
+    /**
+     * 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,
+     *   }
+     * );
+     * ```
+     */
+    async createInstantWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }, { userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
+        return await this.vaultProgram.methods
+            .instantWithdrawVault(amount, isAmountInLp, isWithdrawAll)
+            .accounts({
+            userTransferAuthority,
+            vault,
+            vaultAssetMint,
+            assetTokenProgram,
+        })
+            .instruction();
+    }
     // --------------------------------------- Strategy Instructions
     /**
      * Creates an instruction to add an adaptor to a vault
@@ -632,7 +789,7 @@ class VoltrClient extends AccountUtils {
      * });
      * ```
      */
-    async createAddAdaptorIx({ vault, payer, admin, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, }) {
+    async createAddAdaptorIx({ vault, payer, admin, adaptorProgram, }) {
         return await this.vaultProgram.methods
             .addAdaptor()
             .accountsPartial({
@@ -676,7 +833,7 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createInitializeStrategyIx({ instructionDiscriminator = null, additionalArgs = null, }, { payer, vault, manager, strategy, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createInitializeStrategyIx({ instructionDiscriminator = null, additionalArgs = null, }, { payer, vault, manager, strategy, adaptorProgram, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .initializeStrategy(instructionDiscriminator ?? null, additionalArgs ?? null)
             .accounts({
@@ -727,7 +884,7 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createDepositStrategyIx({ depositAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createDepositStrategyIx({ depositAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .depositStrategy(depositAmount, instructionDiscriminator, additionalArgs)
             .accounts({
@@ -777,7 +934,7 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .withdrawStrategy(withdrawAmount, instructionDiscriminator, additionalArgs)
             .accounts({
@@ -809,7 +966,7 @@ class VoltrClient extends AccountUtils {
      * });
      * ```
      */
-    async createRemoveAdaptorIx({ vault, admin, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, }) {
+    async createRemoveAdaptorIx({ vault, admin, adaptorProgram, }) {
         return await this.vaultProgram.methods
             .removeAdaptor()
             .accountsPartial({
@@ -852,7 +1009,7 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createInitializeDirectWithdrawStrategyIx({ instructionDiscriminator = null, additionalArgs = null, allowUserArgs = false, }, { payer, admin, vault, strategy, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, }) {
+    async createInitializeDirectWithdrawStrategyIx({ instructionDiscriminator = null, additionalArgs = null, allowUserArgs = false, }, { payer, admin, vault, strategy, adaptorProgram, }) {
         return await this.vaultProgram.methods
             .initializeDirectWithdrawStrategy(instructionDiscriminator, additionalArgs, allowUserArgs)
             .accountsPartial({
@@ -897,7 +1054,7 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createDirectWithdrawStrategyIx({ userArgs = null }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createDirectWithdrawStrategyIx({ userArgs = null }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .directWithdrawStrategy(userArgs)
             .accounts({
@@ -912,19 +1069,20 @@ class VoltrClient extends AccountUtils {
             .instruction();
     }
     /**
-     * Creates an instruction to withdraw assets from a strategy via direct withdrawal with tolerance
-     * @param {Object} args - Arguments for the withdrawal
-     * @param {Buffer | null} args.userArgs - Optional user arguments
-     * @param {BN} args.tolerance - Tolerance amount for the withdrawal
+     * Creates an instruction to withdraw assets from a direct withdraw strategy with slippage tolerance
+     *
+     * @param {Object} directWithdrawArgs - Withdrawal arguments
+     * @param {Buffer | null} [directWithdrawArgs.userArgs] - Optional user arguments for the instruction
+     * @param {BN} directWithdrawArgs.tolerance - Slippage tolerance in asset amount (max difference between requested and actual)
      * @param {Object} params - Parameters for withdrawing assets from direct withdraw strategy
      * @param {PublicKey} params.user - Public key of the user
      * @param {PublicKey} params.vault - Public key of the vault
      * @param {PublicKey} params.strategy - Public key of the strategy
      * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
      * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
-     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @param {PublicKey} [params.adaptorProgram] - Public key of the adaptor program (defaults to lending adaptor)
      * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawing assets from direct withdraw strategy with tolerance
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for direct withdraw with tolerance
      * @throws {Error} If instruction creation fails
      *
      * @example
@@ -932,7 +1090,7 @@ class VoltrClient extends AccountUtils {
      * const ix = await client.createDirectWithdrawStrategyWithToleranceIx(
      *   {
      *     userArgs: Buffer.from('...'),
-     *     tolerance: new BN(1)
+     *     tolerance: new BN(1000),
      *   },
      *   {
      *     user: userPubkey,
@@ -940,13 +1098,12 @@ class VoltrClient extends AccountUtils {
      *     strategy: strategyPubkey,
      *     vaultAssetMint: mintPubkey,
      *     assetTokenProgram: tokenProgramPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
+     *     remainingAccounts: [],
      *   }
      * );
      * ```
      */
-    async createDirectWithdrawStrategyWithToleranceIx({ userArgs = null, tolerance }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createDirectWithdrawStrategyWithToleranceIx({ userArgs = null, tolerance }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .directWithdrawStrategyWithTolerance(userArgs, tolerance)
             .accounts({
@@ -960,6 +1117,112 @@ class VoltrClient extends AccountUtils {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
+    /**
+     * 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: [],
+     *   }
+     * );
+     * ```
+     */
+    async createInstantWithdrawStrategyIx({ amount, isAmountInLp, isWithdrawAll, userArgs = null, }, { userTransferAuthority, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
+        return await this.vaultProgram.methods
+            .instantWithdrawStrategy(amount, isAmountInLp, isWithdrawAll, userArgs ?? null)
+            .accounts({
+            userTransferAuthority,
+            vault,
+            strategy,
+            vaultAssetMint,
+            assetTokenProgram,
+            adaptorProgram,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    /**
+     * 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: [],
+     *   }
+     * );
+     * ```
+     */
+    async createInstantWithdrawStrategyWithToleranceIx({ amount, isAmountInLp, isWithdrawAll, userArgs = null, tolerance, }, { userTransferAuthority, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }) {
+        return await this.vaultProgram.methods
+            .instantWithdrawStrategyWithTolerance(amount, isAmountInLp, isWithdrawAll, userArgs ?? null, tolerance)
+            .accounts({
+            userTransferAuthority,
+            vault,
+            strategy,
+            vaultAssetMint,
+            assetTokenProgram,
+            adaptorProgram,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
     /**
      * Creates an instruction to harvest fees from a vault
      * @param {Object} params - Parameters for harvesting fees
@@ -1050,6 +1313,31 @@ class VoltrClient extends AccountUtils {
         })
             .instruction();
     }
+    /**
+     * 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,
+     * });
+     * ```
+     */
+    async createCalibrateHighWaterMarkUnsafeIx({ vault, admin, }) {
+        return await this.vaultProgram.methods
+            .calibrateHighWaterMarkUnsafe()
+            .accountsPartial({
+            vault,
+            admin,
+        })
+            .instruction();
+    }
     /**
      * Creates an instruction to create LP metadata
      * @param {Object} createLpMetadataArgs - Parameters for creating LP metadata
@@ -1084,6 +1372,51 @@ class VoltrClient extends AccountUtils {
         })
             .instruction();
     }
+    /**
+     * 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,
+     *   }
+     * );
+     * ```
+     */
+    async createUpdateVaultProtocolFeeIx(field, feeBps, { admin, vault, }) {
+        const fieldToVariant = {
+            [types_1.ProtocolFeeField.ProtocolPerformanceFee]: {
+                protocolPerformanceFee: {},
+            },
+            [types_1.ProtocolFeeField.ProtocolManagementFee]: {
+                protocolManagementFee: {},
+            },
+        };
+        const fieldVariant = fieldToVariant[field];
+        if (!fieldVariant) {
+            throw new Error(`Unknown protocol fee field: ${field}`);
+        }
+        return await this.vaultProgram.methods
+            .updateVaultProtocolFee(fieldVariant, feeBps)
+            .accountsPartial({
+            admin,
+            vault,
+        })
+            .instruction();
+    }
     // --------------------------------------- Account Fetching All
     /**
      * Fetches all strategy init receipt accounts
@@ -1163,6 +1496,19 @@ class VoltrClient extends AccountUtils {
      * @param vault - Public key of the vault
      * @returns Promise resolving to the vault account data
      */
+    /**
+     * Fetches the protocol account's data
+     * @returns Promise resolving to the protocol account data
+     *
+     * @example
+     * ```typescript
+     * const protocolAccount = await client.fetchProtocolAccount();
+     * ```
+     */
+    async fetchProtocolAccount() {
+        const protocol = this.findProtocol();
+        return await this.vaultProgram.account.protocol.fetch(protocol, this.provider.opts.commitment);
+    }
     async fetchVaultAccount(vault) {
         return await this.vaultProgram.account.vault.fetch(vault, this.provider.opts.commitment);
     }
@@ -1257,6 +1603,20 @@ class VoltrClient extends AccountUtils {
         const vaultAccount = await this.fetchVaultAccount(vault);
         return vaultAccount.feeState.accumulatedLpManagerFees;
     }
+    /**
+     * 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);
+     * ```
+     */
+    async getAccumulatedProtocolFeesForVault(vault) {
+        const vaultAccount = await this.fetchVaultAccount(vault);
+        return vaultAccount.feeState.accumulatedLpProtocolFees;
+    }
     /**
      * Fetches the current asset per LP for a vault
      * @param vault - Public key of the vault
@@ -1274,7 +1634,8 @@ class VoltrClient extends AccountUtils {
         const unharvestedFeesLp = vaultAccount.feeState.accumulatedLpAdminFees
             .add(vaultAccount.feeState.accumulatedLpManagerFees)
             .add(vaultAccount.feeState.accumulatedLpProtocolFees);
-        const totalLpSupply = unharvestedFeesLp.add(lpSupply);
+        const deadWeight = vaultAccount.deadWeight;
+        const totalLpSupply = unharvestedFeesLp.add(lpSupply).add(deadWeight);
         const currentAssetPerLp = vaultAccount.asset.totalValue.toNumber() / totalLpSupply.toNumber();
         return currentAssetPerLp;
     }
@@ -1315,9 +1676,11 @@ class VoltrClient extends AccountUtils {
         const unharvestedFees = vaultAccount.feeState.accumulatedLpAdminFees
             .add(vaultAccount.feeState.accumulatedLpManagerFees)
             .add(vaultAccount.feeState.accumulatedLpProtocolFees);
-        const currentTotalLp = circulating.add(unharvestedFees);
+        const deadWeight = vaultAccount.deadWeight;
+        const currentTotalLp = circulating.add(unharvestedFees).add(deadWeight);
         const unrealisedFees = this.calculateUnrealisedLpFees(currentTotalLp, vaultAccount.asset.totalValue, vaultAccount.feeUpdate.lastManagementFeeUpdateTs, new bn_js_1.default(vaultAccount.feeConfiguration.managerManagementFee +
-            vaultAccount.feeConfiguration.adminManagementFee));
+            vaultAccount.feeConfiguration.adminManagementFee +
+            vaultAccount.feeConfiguration.protocolManagementFee));
         const total = currentTotalLp.add(unrealisedFees);
         return {
             circulating,
@@ -1335,7 +1698,8 @@ class VoltrClient extends AccountUtils {
         const amountAssetToWithdrawAtRequest = amountAssetToWithdrawDecimal.toNumber();
         const amountLpEscrowed = receipt.account.amountLpEscrowed;
         const amountAssetToWithdrawAtPresent = this.calculateAssetsForWithdrawHelper(vaultAccount.asset.totalValue, vaultAccount.lockedProfitState.lastUpdatedLockedProfit, vaultAccount.vaultConfiguration.lockedProfitDegradationDuration, vaultAccount.feeState.accumulatedLpAdminFees, vaultAccount.feeState.accumulatedLpManagerFees, vaultAccount.feeState.accumulatedLpProtocolFees, vaultAccount.feeConfiguration.redemptionFee, vaultAccount.feeConfiguration.managerManagementFee +
-            vaultAccount.feeConfiguration.adminManagementFee, vaultAccount.feeUpdate.lastManagementFeeUpdateTs, lpSupply, amountLpEscrowed).toNumber();
+            vaultAccount.feeConfiguration.adminManagementFee +
+            vaultAccount.feeConfiguration.protocolManagementFee, vaultAccount.feeUpdate.lastManagementFeeUpdateTs, lpSupply, amountLpEscrowed, vaultAccount.deadWeight).toNumber();
         // Cap the withdrawal amount to the initial request amount
         const amountAssetToWithdrawEffective = Math.min(amountAssetToWithdrawAtPresent, amountAssetToWithdrawAtRequest);
         return {
@@ -1428,7 +1792,7 @@ class VoltrClient extends AccountUtils {
             .div(lpDenominator);
         return pendingLpToMint;
     }
-    calculateAssetsForWithdrawHelper(vaultTotalValue, vaultLastUpdatedLockedProfit, vaultLockedProfitDegradationDuration, vaultAccumulatedLpAdminFees, vaultAccumulatedLpManagerFees, vaultAccumulatedLpProtocolFees, vaultRedemptionFeeBps, vaultManagementFeeBps, vaultLastManagementFeeUpdateTs, lpSupply, lpAmount) {
+    calculateAssetsForWithdrawHelper(vaultTotalValue, vaultLastUpdatedLockedProfit, vaultLockedProfitDegradationDuration, vaultAccumulatedLpAdminFees, vaultAccumulatedLpManagerFees, vaultAccumulatedLpProtocolFees, vaultRedemptionFeeBps, vaultManagementFeeBps, vaultLastManagementFeeUpdateTs, lpSupply, lpAmount, deadWeight = new bn_js_1.default(0)) {
         if (lpSupply <= new bn_js_1.default(0))
             throw new Error("Invalid LP supply");
         if (vaultTotalValue <= new bn_js_1.default(0))
@@ -1438,7 +1802,9 @@ class VoltrClient extends AccountUtils {
         const unharvestedFeesLp = vaultAccumulatedLpAdminFees
             .add(vaultAccumulatedLpManagerFees)
             .add(vaultAccumulatedLpProtocolFees);
-        const lpSupplyInclAccumulatedFees = lpSupply.add(unharvestedFeesLp);
+        const lpSupplyInclAccumulatedFees = lpSupply
+            .add(unharvestedFeesLp)
+            .add(deadWeight);
         const unrealisedLpFees = this.calculateUnrealisedLpFees(lpSupplyInclAccumulatedFees, vaultTotalValue, vaultLastManagementFeeUpdateTs, new bn_js_1.default(vaultManagementFeeBps));
         const lpSupplyInclFees = unrealisedLpFees.add(lpSupplyInclAccumulatedFees);
         // asset_to_redeem_pre_fee = amount * (total_asset_pre_withdraw / total_lp_supply_pre_withdraw)
@@ -1474,7 +1840,8 @@ class VoltrClient extends AccountUtils {
             const lpMint = this.findVaultLpMint(vaultPk);
             const lp = await (0, spl_token_1.getMint)(this.conn, lpMint, this.provider.opts.commitment);
             const amount = this.calculateAssetsForWithdrawHelper(vault.asset.totalValue, vault.lockedProfitState.lastUpdatedLockedProfit, vault.vaultConfiguration.lockedProfitDegradationDuration, vault.feeState.accumulatedLpAdminFees, vault.feeState.accumulatedLpManagerFees, vault.feeState.accumulatedLpProtocolFees, vault.feeConfiguration.redemptionFee, vault.feeConfiguration.managerManagementFee +
-                vault.feeConfiguration.adminManagementFee, vault.feeUpdate.lastManagementFeeUpdateTs, new bn_js_1.default(lp.supply.toString()), lpAmount);
+                vault.feeConfiguration.adminManagementFee +
+                vault.feeConfiguration.protocolManagementFee, vault.feeUpdate.lastManagementFeeUpdateTs, new bn_js_1.default(lp.supply.toString()), lpAmount, vault.deadWeight);
             return amount;
         }
         catch (e) {
@@ -1516,9 +1883,12 @@ class VoltrClient extends AccountUtils {
             const unharvestedFeesLp = vault.feeState.accumulatedLpAdminFees
                 .add(vault.feeState.accumulatedLpManagerFees)
                 .add(vault.feeState.accumulatedLpProtocolFees);
-            const lpSupplyInclAccumulatedFees = lpSupply.add(unharvestedFeesLp);
+            const lpSupplyInclAccumulatedFees = lpSupply
+                .add(unharvestedFeesLp)
+                .add(vault.deadWeight);
             const unrealisedLpFees = this.calculateUnrealisedLpFees(lpSupplyInclAccumulatedFees, totalValue, vault.feeUpdate.lastManagementFeeUpdateTs, new bn_js_1.default(vault.feeConfiguration.managerManagementFee +
-                vault.feeConfiguration.adminManagementFee));
+                vault.feeConfiguration.adminManagementFee +
+                vault.feeConfiguration.protocolManagementFee));
             const lpSupplyInclFees = unrealisedLpFees.add(lpSupplyInclAccumulatedFees);
             // lp_to_burn_pre_fee = redeem_amount * (total_lp_supply_pre_withdraw / total_asset_pre_withdraw)
             // lp_to_burn_post_fee = lp_to_burn_pre_fee  * (10000 / (10000 - redemption_fee_bps))
@@ -1559,9 +1929,12 @@ class VoltrClient extends AccountUtils {
         const unharvestedFeesLp = vault.feeState.accumulatedLpAdminFees
             .add(vault.feeState.accumulatedLpManagerFees)
             .add(vault.feeState.accumulatedLpProtocolFees);
-        const lpSupplyInclAccumulatedFees = lpSupply.add(unharvestedFeesLp);
+        const lpSupplyInclAccumulatedFees = lpSupply
+            .add(unharvestedFeesLp)
+            .add(vault.deadWeight);
         const unrealisedLpFees = this.calculateUnrealisedLpFees(lpSupplyInclAccumulatedFees, totalValue, vault.feeUpdate.lastManagementFeeUpdateTs, new bn_js_1.default(vault.feeConfiguration.managerManagementFee +
-            vault.feeConfiguration.adminManagementFee));
+            vault.feeConfiguration.adminManagementFee +
+            vault.feeConfiguration.protocolManagementFee));
         const lpSupplyInclFees = unrealisedLpFees.add(lpSupplyInclAccumulatedFees);
         // If the pool is empty, mint LP tokens 1:1 with deposit
         if (lpSupplyInclFees.eq(new bn_js_1.default(0))) {

package/dist/constants.d.ts

@@ -1,8 +1,6 @@
 import { PublicKey } from "@solana/web3.js";
 import BN from "bn.js";
 export declare const VAULT_PROGRAM_ID: PublicKey;
-export declare const LENDING_ADAPTOR_PROGRAM_ID: PublicKey;
-export declare const DRIFT_ADAPTOR_PROGRAM_ID: PublicKey;
 export declare const METADATA_PROGRAM_ID: PublicKey;
 export declare const SEEDS: {
     PROTOCOL: Buffer<ArrayBuffer>;

package/dist/constants.js

@@ -3,12 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_FEE_BPS_BN = exports.ONE_YEAR_BN = exports.SEEDS = exports.METADATA_PROGRAM_ID = exports.DRIFT_ADAPTOR_PROGRAM_ID = exports.LENDING_ADAPTOR_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
+exports.MAX_FEE_BPS_BN = exports.ONE_YEAR_BN = exports.SEEDS = exports.METADATA_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const bn_js_1 = __importDefault(require("bn.js"));
 exports.VAULT_PROGRAM_ID = new web3_js_1.PublicKey("vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8");
-exports.LENDING_ADAPTOR_PROGRAM_ID = new web3_js_1.PublicKey("aVoLTRCRt3NnnchvLYH6rMYehJHwM5m45RmLBZq7PGz");
-exports.DRIFT_ADAPTOR_PROGRAM_ID = new web3_js_1.PublicKey("EBN93eXs5fHGBABuajQqdsKRkCgaqtJa8vEFD6vKXiP");
 exports.METADATA_PROGRAM_ID = new web3_js_1.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
 exports.SEEDS = {
     PROTOCOL: Buffer.from("protocol"),