@drift-labs/vaults-sdk 0.1.220 → 0.1.221

package/lib/vaultClient.d.ts

@@ -5,7 +5,7 @@ import { BN, DriftClient, UserMap } from '@drift-labs/sdk';
 import { Program, ProgramAccount } from '@coral-xyz/anchor';
 import { DriftVaults } from './types/drift_vaults';
 import { CompetitionsClient } from '@drift-labs/competitions-sdk';
-import { ConfirmOptions, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { Vault, VaultDepositor, WithdrawUnit } from './types/types';
 import { UserMapConfig } from '@drift-labs/sdk/lib/userMap/userMapConfig';
 export type TxParams = {
@@ -93,7 +93,7 @@ export declare class VaultClient {
         profitShare: number | null;
         hurdleRate: number | null;
         permissioned: boolean | null;
-    }, preIxs?: Array<TransactionInstruction>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    }): Promise<TransactionSignature>;
     getApplyProfitShareIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
     private createInitVaultDepositorIx;
     /**
@@ -113,18 +113,18 @@ export declare class VaultClient {
     deposit(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
         authority: PublicKey;
         vault: PublicKey;
-    }): Promise<TransactionSignature>;
-    requestWithdraw(vaultDepositor: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
+    }, txParams?: TxParams): Promise<TransactionSignature>;
+    requestWithdraw(vaultDepositor: PublicKey, amount: BN, withdrawUnit: WithdrawUnit, txParams?: TxParams): Promise<TransactionSignature>;
     withdraw(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
-    forceWithdraw(vaultDepositor: PublicKey, ixOnly?: boolean, preIxs?: Array<TransactionInstruction>, simulate?: boolean, opts?: ConfirmOptions): Promise<TransactionSignature | TransactionInstruction | undefined>;
-    cancelRequestWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    forceWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    cancelRequestWithdraw(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Liquidates (become delegate for) a vault.
      * @param
      * @param
      * @returns
      */
-    liquidate(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    liquidate(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Used for UI wallet adapters compatibility
      */

package/lib/vaultClient.js

@@ -319,15 +319,14 @@ class VaultClient {
             cuLimit: 1000000,
         });
     }
-    async managerUpdateVault(vault, params, preIxs, opts) {
-        let builder = this.program.methods.updateVault(params).accounts({
+    async managerUpdateVault(vault, params) {
+        return await this.program.methods
+            .updateVault(params)
+            .accounts({
             vault,
             manager: this.driftClient.wallet.publicKey,
-        });
-        if (preIxs) {
-            builder = builder.preInstructions(preIxs);
-        }
-        return builder.rpc(opts);
+        })
+            .rpc();
     }
     async getApplyProfitShareIx(vault, vaultDepositor) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
@@ -405,7 +404,7 @@ class VaultClient {
      * @param initVaultDepositor If true, will initialize the vault depositor account
      * @returns
      */
-    async deposit(vaultDepositor, amount, initVaultDepositor) {
+    async deposit(vaultDepositor, amount, initVaultDepositor, txParams) {
         let vaultPubKey;
         if (initVaultDepositor) {
             vaultPubKey = initVaultDepositor.vault;
@@ -458,14 +457,14 @@ class VaultClient {
             });
             if (initVaultDepositor) {
                 const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
-                return await this.createAndSendTxn([initIx, depositIx]);
+                return await this.createAndSendTxn([initIx, depositIx], txParams);
             }
             else {
-                return await this.createAndSendTxn([depositIx]);
+                return await this.createAndSendTxn([depositIx], txParams);
             }
         }
     }
-    async requestWithdraw(vaultDepositor, amount, withdrawUnit) {
+    async requestWithdraw(vaultDepositor, amount, withdrawUnit, txParams) {
         const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
         const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
         const user = await this.getSubscribedVaultUser(vaultAccount.user);
@@ -496,9 +495,7 @@ class VaultClient {
                 },
                 remainingAccounts,
             });
-            return await this.createAndSendTxn([requestWithdrawIx], {
-                cuLimit: 650000,
-            });
+            return await this.createAndSendTxn([requestWithdrawIx], txParams);
         }
     }
     async withdraw(vaultDepositor, txParams) {
@@ -561,7 +558,7 @@ class VaultClient {
             });
         }
     }
-    async forceWithdraw(vaultDepositor, ixOnly, preIxs, simulate, opts) {
+    async forceWithdraw(vaultDepositor) {
         const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
         const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
         const user = await this.getSubscribedVaultUser(vaultAccount.user);
@@ -590,52 +587,16 @@ class VaultClient {
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         if (this.cliMode) {
-            if (ixOnly) {
-                return await this.program.methods
-                    .forceWithdraw()
-                    .accounts(accounts)
-                    .remainingAccounts(remainingAccounts)
-                    .instruction();
-            }
-            else if (simulate) {
-                let builder = this.program.methods.forceWithdraw();
-                if (preIxs) {
-                    builder = builder.preInstructions(preIxs);
-                }
-                else {
-                    builder = builder.preInstructions([
-                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                            units: 600000,
-                        }),
-                    ]);
-                }
-                const simResult = await builder
-                    .accounts(accounts)
-                    .remainingAccounts(remainingAccounts)
-                    .simulate();
-                console.log(simResult);
-                console.log(simResult.events);
-            }
-            else {
-                let builder = this.program.methods.forceWithdraw();
-                if (preIxs) {
-                    builder = builder.preInstructions(preIxs);
-                }
-                else {
-                    builder = builder.preInstructions([
-                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                            units: 600000,
-                        }),
-                        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                            microLamports: 100000,
-                        }),
-                    ]);
-                }
-                return await builder
-                    .accounts(accounts)
-                    .remainingAccounts(remainingAccounts)
-                    .rpc(opts);
-            }
+            return await this.program.methods
+                .forceWithdraw()
+                .preInstructions([
+                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 400000,
+                }),
+            ])
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
         }
         else {
             const forceWithdrawIx = this.program.instruction.forceWithdraw({
@@ -647,7 +608,7 @@ class VaultClient {
             return await this.createAndSendTxn([forceWithdrawIx]);
         }
     }
-    async cancelRequestWithdraw(vaultDepositor) {
+    async cancelRequestWithdraw(vaultDepositor, txParams) {
         const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
         const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
@@ -678,7 +639,7 @@ class VaultClient {
                 },
                 remainingAccounts,
             });
-            return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+            return await this.createAndSendTxn([cancelRequestWithdrawIx], txParams);
         }
     }
     /**
@@ -687,7 +648,7 @@ class VaultClient {
      * @param
      * @returns
      */
-    async liquidate(vaultDepositor) {
+    async liquidate(vaultDepositor, txParams) {
         const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
         const vaultPubKey = vaultDepositorAccount.vault;
         const vaultAccount = await this.program.account.vault.fetch(vaultPubKey);
@@ -722,7 +683,7 @@ class VaultClient {
                 },
                 remainingAccounts,
             });
-            return await this.createAndSendTxn([liquidateIx]);
+            return await this.createAndSendTxn([liquidateIx], txParams);
         }
     }
     /**
@@ -735,7 +696,7 @@ class VaultClient {
                 units: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.cuLimit) !== null && _a !== void 0 ? _a : 400000,
             }),
             web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) !== null && _b !== void 0 ? _b : 80000,
+                microLamports: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) !== null && _b !== void 0 ? _b : 1000000,
             }),
             ...vaultIxs,
         ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/vaults-sdk",
-  "version": "0.1.220",
+  "version": "0.1.221",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "directories": {
@@ -9,7 +9,7 @@
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@drift-labs/competitions-sdk": "0.2.186",
-    "@drift-labs/sdk": "2.72.0-beta.2",
+    "@drift-labs/sdk": "2.72.0-beta.3",
     "@solana/web3.js": "1.73.2",
     "commander": "^11.0.0",
     "dotenv": "^16.3.1",

package/src/vaultClient.ts

@@ -22,7 +22,6 @@ import {
 } from './addresses';
 import {
 	ComputeBudgetProgram,
-	ConfirmOptions,
 	PublicKey,
 	SystemProgram,
 	SYSVAR_RENT_PUBKEY,
@@ -525,19 +524,15 @@ export class VaultClient {
 			profitShare: number | null;
 			hurdleRate: number | null;
 			permissioned: boolean | null;
-		},
-		preIxs?: Array<TransactionInstruction>,
-		opts?: ConfirmOptions
-	): Promise<TransactionSignature> {
-		let builder = this.program.methods.updateVault(params).accounts({
-			vault,
-			manager: this.driftClient.wallet.publicKey,
-		});
-		if (preIxs) {
-			builder = builder.preInstructions(preIxs);
 		}
-
-		return builder.rpc(opts);
+	): Promise<TransactionSignature> {
+		return await this.program.methods
+			.updateVault(params)
+			.accounts({
+				vault,
+				manager: this.driftClient.wallet.publicKey,
+			})
+			.rpc();
 	}
 
 	public async getApplyProfitShareIx(
@@ -658,7 +653,8 @@ export class VaultClient {
 		initVaultDepositor?: {
 			authority: PublicKey;
 			vault: PublicKey;
-		}
+		},
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		let vaultPubKey: PublicKey;
 		if (initVaultDepositor) {
@@ -736,9 +732,9 @@ export class VaultClient {
 					vaultAccount.pubkey,
 					initVaultDepositor.authority
 				);
-				return await this.createAndSendTxn([initIx, depositIx]);
+				return await this.createAndSendTxn([initIx, depositIx], txParams);
 			} else {
-				return await this.createAndSendTxn([depositIx]);
+				return await this.createAndSendTxn([depositIx], txParams);
 			}
 		}
 	}
@@ -746,7 +742,8 @@ export class VaultClient {
 	public async requestWithdraw(
 		vaultDepositor: PublicKey,
 		amount: BN,
-		withdrawUnit: WithdrawUnit
+		withdrawUnit: WithdrawUnit,
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultDepositorAccount =
 			await this.program.account.vaultDepositor.fetch(vaultDepositor);
@@ -793,9 +790,7 @@ export class VaultClient {
 				}
 			);
 
-			return await this.createAndSendTxn([requestWithdrawIx], {
-				cuLimit: 650_000,
-			});
+			return await this.createAndSendTxn([requestWithdrawIx], txParams);
 		}
 	}
 
@@ -892,12 +887,8 @@ export class VaultClient {
 	}
 
 	public async forceWithdraw(
-		vaultDepositor: PublicKey,
-		ixOnly?: boolean,
-		preIxs?: Array<TransactionInstruction>,
-		simulate?: boolean,
-		opts?: ConfirmOptions
-	): Promise<TransactionSignature | TransactionInstruction | undefined> {
+		vaultDepositor: PublicKey
+	): Promise<TransactionSignature> {
 		const vaultDepositorAccount =
 			await this.program.account.vaultDepositor.fetch(vaultDepositor);
 		const vaultAccount = await this.program.account.vault.fetch(
@@ -946,49 +937,16 @@ export class VaultClient {
 		};
 
 		if (this.cliMode) {
-			if (ixOnly) {
-				return await this.program.methods
-					.forceWithdraw()
-					.accounts(accounts)
-					.remainingAccounts(remainingAccounts)
-					.instruction();
-			} else if (simulate) {
-				let builder = this.program.methods.forceWithdraw();
-				if (preIxs) {
-					builder = builder.preInstructions(preIxs);
-				} else {
-					builder = builder.preInstructions([
-						ComputeBudgetProgram.setComputeUnitLimit({
-							units: 600_000,
-						}),
-					]);
-				}
-				const simResult = await builder
-					.accounts(accounts)
-					.remainingAccounts(remainingAccounts)
-					.simulate();
-
-				console.log(simResult);
-				console.log(simResult.events);
-			} else {
-				let builder = this.program.methods.forceWithdraw();
-				if (preIxs) {
-					builder = builder.preInstructions(preIxs);
-				} else {
-					builder = builder.preInstructions([
-						ComputeBudgetProgram.setComputeUnitLimit({
-							units: 600_000,
-						}),
-						ComputeBudgetProgram.setComputeUnitPrice({
-							microLamports: 100_000,
-						}),
-					]);
-				}
-				return await builder
-					.accounts(accounts)
-					.remainingAccounts(remainingAccounts)
-					.rpc(opts);
-			}
+			return await this.program.methods
+				.forceWithdraw()
+				.preInstructions([
+					ComputeBudgetProgram.setComputeUnitLimit({
+						units: 400_000,
+					}),
+				])
+				.accounts(accounts)
+				.remainingAccounts(remainingAccounts)
+				.rpc();
 		} else {
 			const forceWithdrawIx = this.program.instruction.forceWithdraw({
 				accounts: {
@@ -1001,7 +959,8 @@ export class VaultClient {
 	}
 
 	public async cancelRequestWithdraw(
-		vaultDepositor: PublicKey
+		vaultDepositor: PublicKey,
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultDepositorAccount =
 			await this.program.account.vaultDepositor.fetch(vaultDepositor);
@@ -1045,7 +1004,7 @@ export class VaultClient {
 					remainingAccounts,
 				});
 
-			return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+			return await this.createAndSendTxn([cancelRequestWithdrawIx], txParams);
 		}
 	}
 
@@ -1056,7 +1015,8 @@ export class VaultClient {
 	 * @returns
 	 */
 	public async liquidate(
-		vaultDepositor: PublicKey
+		vaultDepositor: PublicKey,
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultDepositorAccount =
 			await this.program.account.vaultDepositor.fetch(vaultDepositor);
@@ -1102,7 +1062,7 @@ export class VaultClient {
 				remainingAccounts,
 			});
 
-			return await this.createAndSendTxn([liquidateIx]);
+			return await this.createAndSendTxn([liquidateIx], txParams);
 		}
 	}
 
@@ -1118,7 +1078,7 @@ export class VaultClient {
 				units: txParams?.cuLimit ?? 400_000,
 			}),
 			ComputeBudgetProgram.setComputeUnitPrice({
-				microLamports: txParams?.cuPriceMicroLamports ?? 80_000,
+				microLamports: txParams?.cuPriceMicroLamports ?? 1_000_000,
 			}),
 			...vaultIxs,
 		];