@drift-labs/vaults-sdk 0.2.52 → 0.2.54

package/lib/vaultClient.d.ts

@@ -110,7 +110,7 @@ export declare class VaultClient {
         hurdleRate: number;
         permissioned: boolean;
         vaultProtocol?: VaultProtocolParams;
-    }): Promise<TransactionSignature>;
+    }, uiTxParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Updates the delegate address for a vault. The delegate address will be allowed to trade
      * on behalf of the vault.
@@ -118,24 +118,25 @@ export declare class VaultClient {
      * @param delegate delegate address to update to
      * @returns
      */
-    updateDelegate(vault: PublicKey, delegate: PublicKey): Promise<TransactionSignature>;
+    updateDelegate(vault: PublicKey, delegate: PublicKey, uiTxParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Updates the vault margin trading status.
      * @param vault vault address to update
      * @param enabled whether to enable margin trading
      * @returns
      */
-    updateMarginTradingEnabled(vault: PublicKey, enabled: boolean): Promise<TransactionSignature>;
+    updateMarginTradingEnabled(vault: PublicKey, enabled: boolean, uiTxParams?: TxParams): Promise<TransactionSignature>;
+    private handleWSolMovement;
     /**
      *
      * @param vault vault address to deposit to
      * @param amount amount to deposit
      * @returns
      */
-    managerDeposit(vault: PublicKey, amount: BN): Promise<TransactionSignature>;
-    managerRequestWithdraw(vault: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
-    managerCancelWithdrawRequest(vault: PublicKey): Promise<TransactionSignature>;
-    managerWithdraw(vault: PublicKey): Promise<TransactionSignature>;
+    managerDeposit(vault: PublicKey, amount: BN, uiTxParams?: TxParams): Promise<TransactionSignature>;
+    managerRequestWithdraw(vault: PublicKey, amount: BN, withdrawUnit: WithdrawUnit, uiTxParams?: TxParams): Promise<TransactionSignature>;
+    managerCancelWithdrawRequest(vault: PublicKey, uiTxParams?: TxParams): Promise<TransactionSignature>;
+    managerWithdraw(vault: PublicKey, uiTxParams?: TxParams): Promise<TransactionSignature>;
     managerUpdateVault(vault: PublicKey, params: {
         redeemPeriod: BN | null;
         maxTokens: BN | null;
@@ -144,7 +145,7 @@ export declare class VaultClient {
         profitShare: number | null;
         hurdleRate: number | null;
         permissioned: boolean | null;
-    }): Promise<TransactionSignature>;
+    }, uiTxParams?: TxParams): Promise<TransactionSignature>;
     getApplyProfitShareIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
     getApplyRebaseTokenizedDepositorIx(vault: PublicKey, tokenizedVaultDepositor: PublicKey): Promise<TransactionInstruction>;
     applyRebase(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionSignature>;
@@ -157,7 +158,7 @@ export declare class VaultClient {
      * @param authority the authority allowed to make deposits into the vault
      * @returns
      */
-    initializeVaultDepositor(vault: PublicKey, authority?: PublicKey, payer?: PublicKey): Promise<TransactionSignature>;
+    initializeVaultDepositor(vault: PublicKey, authority?: PublicKey, payer?: PublicKey, uiTxParams?: TxParams): Promise<TransactionSignature>;
     initializeTokenizedVaultDepositor(params: {
         vault: PublicKey;
         tokenName: string;

package/lib/vaultClient.js

@@ -282,7 +282,7 @@ class VaultClient {
         const vpAccount = await this.program.account.vaultProtocol.fetch(vaultProtocol);
         return (0, sdk_1.unstakeSharesToAmount)(vpAccount.protocolProfitAndFeeShares, vaultAccount.totalShares, vaultTotalEquity);
     }
-    async initializeVault(params) {
+    async initializeVault(params, uiTxParams) {
         const { vaultProtocol: vaultProtocolParams, ...vaultParams } = params;
         const vault = (0, addresses_1.getVaultAddressSync)(this.program.programId, params.name);
         const tokenAccount = (0, addresses_1.getTokenVaultAddressSync)(this.program.programId, vault);
@@ -303,42 +303,67 @@ class VaultClient {
             tokenAccount,
             driftProgram: this.driftClient.program.programId,
         };
+        const preIxs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: 400000,
+            }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 300000,
+            }),
+        ];
         if (vaultProtocolParams) {
             const vaultProtocol = this.getVaultProtocolAddress((0, addresses_1.getVaultAddressSync)(this.program.programId, params.name));
             const _params = {
                 ...vaultParams,
                 vaultProtocol: vaultProtocolParams,
             };
-            return await this.program.methods
-                .initializeVaultWithProtocol(_params)
-                .preInstructions([
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 400000,
-                }),
-                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 300000,
-                }),
-            ])
-                .accounts({
-                ...accounts,
-                vaultProtocol,
-            })
-                .rpc();
+            if (this.cliMode) {
+                return await this.program.methods
+                    .initializeVaultWithProtocol(_params)
+                    .preInstructions(preIxs)
+                    .accounts({
+                    ...accounts,
+                    vaultProtocol,
+                })
+                    .rpc();
+            }
+            else {
+                const uiAuthority = this.driftClient.wallet.publicKey;
+                const initializeVaultWithProtocolIx = await this.program.methods
+                    .initializeVaultWithProtocol(_params)
+                    .accounts({
+                    ...accounts,
+                    vaultProtocol,
+                    payer: uiAuthority,
+                    manager: uiAuthority,
+                })
+                    .instruction();
+                const ixs = [...preIxs, initializeVaultWithProtocolIx];
+                return await this.createAndSendTxn(ixs, uiTxParams);
+            }
         }
         else {
             const _params = vaultParams;
-            return await this.program.methods
-                .initializeVault(_params)
-                .preInstructions([
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 400000,
-                }),
-                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 300000,
-                }),
-            ])
-                .accounts(accounts)
-                .rpc();
+            if (this.cliMode) {
+                return await this.program.methods
+                    .initializeVault(_params)
+                    .preInstructions(preIxs)
+                    .accounts(accounts)
+                    .rpc();
+            }
+            else {
+                const uiAuthority = this.driftClient.wallet.publicKey;
+                const initializeVaultIx = await this.program.methods
+                    .initializeVault(_params)
+                    .accounts({
+                    ...accounts,
+                    payer: uiAuthority,
+                    manager: uiAuthority,
+                })
+                    .instruction();
+                const ixs = [initializeVaultIx];
+                return await this.createAndSendTxn(ixs, uiTxParams);
+            }
         }
     }
     /**
@@ -348,24 +373,34 @@ class VaultClient {
      * @param delegate delegate address to update to
      * @returns
      */
-    async updateDelegate(vault, delegate) {
+    async updateDelegate(vault, delegate, uiTxParams) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
-        return await this.program.methods
-            .updateDelegate(delegate)
-            .preInstructions([
-            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                units: 400000,
-            }),
-            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: 300000,
-            }),
-        ])
-            .accounts({
+        const accounts = {
             vault: vault,
             driftUser: vaultAccount.user,
             driftProgram: this.driftClient.program.programId,
-        })
-            .rpc();
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .updateDelegate(delegate)
+                .preInstructions([
+                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 400000,
+                }),
+                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 300000,
+                }),
+            ])
+                .accounts(accounts)
+                .rpc();
+        }
+        else {
+            const updateDelegateIx = await this.program.methods
+                .updateDelegate(delegate)
+                .accounts({ ...accounts, manager: this.driftClient.wallet.publicKey })
+                .instruction();
+            return await this.createAndSendTxn([updateDelegateIx], uiTxParams);
+        }
     }
     /**
      * Updates the vault margin trading status.
@@ -373,16 +408,38 @@ class VaultClient {
      * @param enabled whether to enable margin trading
      * @returns
      */
-    async updateMarginTradingEnabled(vault, enabled) {
+    async updateMarginTradingEnabled(vault, enabled, uiTxParams) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
-        return await this.program.methods
-            .updateMarginTradingEnabled(enabled)
-            .accounts({
+        const accounts = {
             vault: vault,
             driftUser: vaultAccount.user,
             driftProgram: this.driftClient.program.programId,
-        })
-            .rpc();
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .updateMarginTradingEnabled(enabled)
+                .accounts(accounts)
+                .rpc();
+        }
+        else {
+            const updateMarginTradingEnabledIx = await this.program.methods
+                .updateMarginTradingEnabled(enabled)
+                .accounts({ ...accounts, manager: this.driftClient.wallet.publicKey })
+                .instruction();
+            return await this.createAndSendTxn([updateMarginTradingEnabledIx], uiTxParams);
+        }
+    }
+    async handleWSolMovement(amount, driftSpotMarket, userTokenAccount) {
+        const isSolDeposit = driftSpotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT);
+        const preIxs = [];
+        const postIxs = [];
+        if (isSolDeposit) {
+            const { ixs: createWSolAccountIxs, pubkey } = await this.driftClient.getWrappedSolAccountCreationIxs(amount, true);
+            userTokenAccount = pubkey;
+            preIxs.push(...createWSolAccountIxs);
+            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(userTokenAccount, this.driftClient.wallet.publicKey, this.driftClient.wallet.publicKey, []));
+        }
+        return { userTokenAccount, preIxs, postIxs };
     }
     /**
      *
@@ -390,7 +447,7 @@ class VaultClient {
      * @param amount amount to deposit
      * @returns
      */
-    async managerDeposit(vault, amount) {
+    async managerDeposit(vault, amount, uiTxParams) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
         const driftSpotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
         if (!driftSpotMarket) {
@@ -409,24 +466,41 @@ class VaultClient {
                 isWritable: true,
             });
         }
-        // TODO: handle SOL deposits (need to create/destroy WSOL token accounts)
-        return await this.program.methods
-            .managerDeposit(amount)
-            .accounts({
+        const accounts = {
             vault,
             vaultTokenAccount: vaultAccount.tokenAccount,
             driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
-            driftProgram: this.driftClient.program.programId,
             driftUserStats: (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftProgram: this.driftClient.program.programId,
             driftState: await this.driftClient.getStatePublicKey(),
             driftSpotMarketVault: driftSpotMarket.vault,
             userTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(driftSpotMarket.mint, this.driftClient.wallet.publicKey),
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-        })
-            .remainingAccounts(remainingAccounts)
-            .rpc();
+        };
+        const { userTokenAccount, preIxs, postIxs } = await this.handleWSolMovement(amount, driftSpotMarket, accounts.userTokenAccount);
+        if (this.cliMode) {
+            return await this.program.methods
+                .managerDeposit(amount)
+                .accounts({ ...accounts, userTokenAccount })
+                .remainingAccounts(remainingAccounts)
+                .preInstructions(preIxs)
+                .postInstructions(postIxs)
+                .rpc();
+        }
+        else {
+            const managerDepositIx = await this.program.methods
+                .managerDeposit(amount)
+                .accounts({
+                ...accounts,
+                userTokenAccount,
+                manager: this.driftClient.wallet.publicKey,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return await this.createAndSendTxn([...preIxs, managerDepositIx, ...postIxs], uiTxParams);
+        }
     }
-    async managerRequestWithdraw(vault, amount, withdrawUnit) {
+    async managerRequestWithdraw(vault, amount, withdrawUnit, uiTxParams) {
         this.program.idl.types;
         // @ts-ignore
         const vaultAccount = (await this.program.account.vault.fetch(vault));
@@ -472,10 +546,10 @@ class VaultClient {
                 },
                 remainingAccounts,
             });
-            return await this.createAndSendTxn([requestWithdrawIx]);
+            return await this.createAndSendTxn([requestWithdrawIx], uiTxParams);
         }
     }
-    async managerCancelWithdrawRequest(vault) {
+    async managerCancelWithdrawRequest(vault, uiTxParams) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
         const driftStateKey = await this.driftClient.getStatePublicKey();
@@ -513,10 +587,10 @@ class VaultClient {
                 },
                 remainingAccounts,
             });
-            return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+            return await this.createAndSendTxn([cancelRequestWithdrawIx], uiTxParams);
         }
     }
-    async managerWithdraw(vault) {
+    async managerWithdraw(vault, uiTxParams) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
         if (!this.driftClient.wallet.publicKey.equals(vaultAccount.manager)) {
             throw new Error(`Only the manager of the vault can request a withdraw.`);
@@ -554,21 +628,24 @@ class VaultClient {
             },
             remainingAccounts,
         });
-        return this.createAndSendTxn([ix], {
-            cuLimit: 1000000,
-        });
+        return this.createAndSendTxn([ix], uiTxParams);
     }
-    async managerUpdateVault(vault, params) {
+    async managerUpdateVault(vault, params, uiTxParams) {
         const ix = this.program.instruction.updateVault(params, {
             accounts: {
                 vault,
                 manager: this.driftClient.wallet.publicKey,
             },
         });
-        return this.createAndSendTxn([ix], {
-            cuLimit: 600000,
-            cuPriceMicroLamports: 10000,
-        });
+        if (this.cliMode) {
+            return this.createAndSendTxn([ix], {
+                cuLimit: 600000,
+                cuPriceMicroLamports: 10000,
+            });
+        }
+        else {
+            return this.createAndSendTxn([ix], uiTxParams);
+        }
     }
     async getApplyProfitShareIx(vault, vaultDepositor) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
@@ -683,7 +760,7 @@ class VaultClient {
      * @param authority the authority allowed to make deposits into the vault
      * @returns
      */
-    async initializeVaultDepositor(vault, authority, payer) {
+    async initializeVaultDepositor(vault, authority, payer, uiTxParams) {
         const vaultDepositor = (0, addresses_1.getVaultDepositorAddressSync)(this.program.programId, vault, authority || this.driftClient.wallet.publicKey);
         const accounts = {
             vaultDepositor,
@@ -703,7 +780,7 @@ class VaultClient {
         }
         else {
             const initIx = this.createInitVaultDepositorIx(vault, authority, payer);
-            return await this.createAndSendTxn([initIx]);
+            return await this.createAndSendTxn([initIx], uiTxParams);
         }
     }
     async initializeTokenizedVaultDepositor(params) {
@@ -884,16 +961,8 @@ class VaultClient {
         if (!spotMarket) {
             throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
         }
-        let userTokenAccount = depositTokenAccount !== null && depositTokenAccount !== void 0 ? depositTokenAccount : (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true);
-        const isSolDeposit = spotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT);
-        const preIxs = [];
-        const postIxs = [];
-        if (isSolDeposit) {
-            const { ixs, pubkey } = await this.driftClient.getWrappedSolAccountCreationIxs(amount, true);
-            userTokenAccount = pubkey;
-            preIxs.push(...ixs);
-            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(userTokenAccount, this.driftClient.wallet.publicKey, this.driftClient.wallet.publicKey, []));
-        }
+        const nonWSolUserTokenAccount = depositTokenAccount !== null && depositTokenAccount !== void 0 ? depositTokenAccount : (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true);
+        const { userTokenAccount, preIxs, postIxs } = await this.handleWSolMovement(amount, spotMarket, nonWSolUserTokenAccount);
         const accounts = {
             vault: vaultPubKey,
             vaultDepositor,
@@ -902,7 +971,7 @@ class VaultClient {
             driftUser: vaultAccount.user,
             driftState: driftStateKey,
             driftSpotMarketVault: spotMarket.vault,
-            userTokenAccount,
+            userTokenAccount: userTokenAccount,
             driftProgram: this.driftClient.program.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/vaults-sdk",
-	"version": "0.2.52",
+	"version": "0.2.54",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"directories": {

package/src/vaultClient.ts

@@ -12,6 +12,7 @@ import {
 	getInsuranceFundVaultPublicKey,
 	OracleSource,
 	WRAPPED_SOL_MINT,
+	SpotMarketAccount,
 } from '@drift-labs/sdk';
 import { BorshAccountsCoder, Program, ProgramAccount } from '@coral-xyz/anchor';
 import { DriftVaults } from './types/drift_vaults';
@@ -455,18 +456,21 @@ export class VaultClient {
 		);
 	}
 
-	public async initializeVault(params: {
-		name: number[];
-		spotMarketIndex: number;
-		redeemPeriod: BN;
-		maxTokens: BN;
-		minDepositAmount: BN;
-		managementFee: BN;
-		profitShare: number;
-		hurdleRate: number;
-		permissioned: boolean;
-		vaultProtocol?: VaultProtocolParams;
-	}): Promise<TransactionSignature> {
+	public async initializeVault(
+		params: {
+			name: number[];
+			spotMarketIndex: number;
+			redeemPeriod: BN;
+			maxTokens: BN;
+			minDepositAmount: BN;
+			managementFee: BN;
+			profitShare: number;
+			hurdleRate: number;
+			permissioned: boolean;
+			vaultProtocol?: VaultProtocolParams;
+		},
+		uiTxParams?: TxParams
+	): Promise<TransactionSignature> {
 		const { vaultProtocol: vaultProtocolParams, ...vaultParams } = params;
 		const vault = getVaultAddressSync(this.program.programId, params.name);
 		const tokenAccount = getTokenVaultAddressSync(
@@ -504,6 +508,15 @@ export class VaultClient {
 			driftProgram: this.driftClient.program.programId,
 		};
 
+		const preIxs = [
+			ComputeBudgetProgram.setComputeUnitLimit({
+				units: 400_000,
+			}),
+			ComputeBudgetProgram.setComputeUnitPrice({
+				microLamports: 300_000,
+			}),
+		];
+
 		if (vaultProtocolParams) {
 			const vaultProtocol = this.getVaultProtocolAddress(
 				getVaultAddressSync(this.program.programId, params.name)
@@ -512,35 +525,52 @@ export class VaultClient {
 				...vaultParams,
 				vaultProtocol: vaultProtocolParams,
 			};
-			return await this.program.methods
-				.initializeVaultWithProtocol(_params)
-				.preInstructions([
-					ComputeBudgetProgram.setComputeUnitLimit({
-						units: 400_000,
-					}),
-					ComputeBudgetProgram.setComputeUnitPrice({
-						microLamports: 300_000,
-					}),
-				])
-				.accounts({
-					...accounts,
-					vaultProtocol,
-				})
-				.rpc();
+
+			if (this.cliMode) {
+				return await this.program.methods
+					.initializeVaultWithProtocol(_params)
+					.preInstructions(preIxs)
+					.accounts({
+						...accounts,
+						vaultProtocol,
+					})
+					.rpc();
+			} else {
+				const uiAuthority = this.driftClient.wallet.publicKey;
+				const initializeVaultWithProtocolIx = await this.program.methods
+					.initializeVaultWithProtocol(_params)
+					.accounts({
+						...accounts,
+						vaultProtocol,
+						payer: uiAuthority,
+						manager: uiAuthority,
+					})
+					.instruction();
+				const ixs = [...preIxs, initializeVaultWithProtocolIx];
+				return await this.createAndSendTxn(ixs, uiTxParams);
+			}
 		} else {
 			const _params: VaultParams = vaultParams;
-			return await this.program.methods
-				.initializeVault(_params)
-				.preInstructions([
-					ComputeBudgetProgram.setComputeUnitLimit({
-						units: 400_000,
-					}),
-					ComputeBudgetProgram.setComputeUnitPrice({
-						microLamports: 300_000,
-					}),
-				])
-				.accounts(accounts)
-				.rpc();
+
+			if (this.cliMode) {
+				return await this.program.methods
+					.initializeVault(_params)
+					.preInstructions(preIxs)
+					.accounts(accounts)
+					.rpc();
+			} else {
+				const uiAuthority = this.driftClient.wallet.publicKey;
+				const initializeVaultIx = await this.program.methods
+					.initializeVault(_params)
+					.accounts({
+						...accounts,
+						payer: uiAuthority,
+						manager: uiAuthority,
+					})
+					.instruction();
+				const ixs = [initializeVaultIx];
+				return await this.createAndSendTxn(ixs, uiTxParams);
+			}
 		}
 	}
 
@@ -553,25 +583,36 @@ export class VaultClient {
 	 */
 	public async updateDelegate(
 		vault: PublicKey,
-		delegate: PublicKey
+		delegate: PublicKey,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultAccount = await this.program.account.vault.fetch(vault);
-		return await this.program.methods
-			.updateDelegate(delegate)
-			.preInstructions([
-				ComputeBudgetProgram.setComputeUnitLimit({
-					units: 400_000,
-				}),
-				ComputeBudgetProgram.setComputeUnitPrice({
-					microLamports: 300_000,
-				}),
-			])
-			.accounts({
-				vault: vault,
-				driftUser: vaultAccount.user,
-				driftProgram: this.driftClient.program.programId,
-			})
-			.rpc();
+		const accounts = {
+			vault: vault,
+			driftUser: vaultAccount.user,
+			driftProgram: this.driftClient.program.programId,
+		};
+
+		if (this.cliMode) {
+			return await this.program.methods
+				.updateDelegate(delegate)
+				.preInstructions([
+					ComputeBudgetProgram.setComputeUnitLimit({
+						units: 400_000,
+					}),
+					ComputeBudgetProgram.setComputeUnitPrice({
+						microLamports: 300_000,
+					}),
+				])
+				.accounts(accounts)
+				.rpc();
+		} else {
+			const updateDelegateIx = await this.program.methods
+				.updateDelegate(delegate)
+				.accounts({ ...accounts, manager: this.driftClient.wallet.publicKey })
+				.instruction();
+			return await this.createAndSendTxn([updateDelegateIx], uiTxParams);
+		}
 	}
 
 	/**
@@ -582,17 +623,60 @@ export class VaultClient {
 	 */
 	public async updateMarginTradingEnabled(
 		vault: PublicKey,
-		enabled: boolean
+		enabled: boolean,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultAccount = await this.program.account.vault.fetch(vault);
-		return await this.program.methods
-			.updateMarginTradingEnabled(enabled)
-			.accounts({
-				vault: vault,
-				driftUser: vaultAccount.user,
-				driftProgram: this.driftClient.program.programId,
-			})
-			.rpc();
+		const accounts = {
+			vault: vault,
+			driftUser: vaultAccount.user,
+			driftProgram: this.driftClient.program.programId,
+		};
+
+		if (this.cliMode) {
+			return await this.program.methods
+				.updateMarginTradingEnabled(enabled)
+				.accounts(accounts)
+				.rpc();
+		} else {
+			const updateMarginTradingEnabledIx = await this.program.methods
+				.updateMarginTradingEnabled(enabled)
+				.accounts({ ...accounts, manager: this.driftClient.wallet.publicKey })
+				.instruction();
+			return await this.createAndSendTxn(
+				[updateMarginTradingEnabledIx],
+				uiTxParams
+			);
+		}
+	}
+
+	private async handleWSolMovement(
+		amount: BN,
+		driftSpotMarket: SpotMarketAccount,
+		userTokenAccount: PublicKey
+	) {
+		const isSolDeposit = driftSpotMarket.mint.equals(WRAPPED_SOL_MINT);
+		const preIxs: TransactionInstruction[] = [];
+		const postIxs: TransactionInstruction[] = [];
+
+		if (isSolDeposit) {
+			const { ixs: createWSolAccountIxs, pubkey } =
+				await this.driftClient.getWrappedSolAccountCreationIxs(amount, true);
+
+			userTokenAccount = pubkey;
+
+			preIxs.push(...createWSolAccountIxs);
+			postIxs.push(
+				createCloseAccountInstruction(
+					userTokenAccount,
+					this.driftClient.wallet.publicKey,
+					this.driftClient.wallet.publicKey,
+					[]
+				)
+			);
+		}
+
+		return { userTokenAccount, preIxs, postIxs };
 	}
 
 	/**
@@ -603,7 +687,8 @@ export class VaultClient {
 	 */
 	public async managerDeposit(
 		vault: PublicKey,
-		amount: BN
+		amount: BN,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultAccount = await this.program.account.vault.fetch(vault);
 		const driftSpotMarket = this.driftClient.getSpotMarketAccount(
@@ -630,38 +715,63 @@ export class VaultClient {
 			});
 		}
 
-		// TODO: handle SOL deposits (need to create/destroy WSOL token accounts)
+		const accounts = {
+			vault,
+			vaultTokenAccount: vaultAccount.tokenAccount,
+			driftUser: await getUserAccountPublicKey(
+				this.driftClient.program.programId,
+				vault
+			),
+			driftUserStats: getUserStatsAccountPublicKey(
+				this.driftClient.program.programId,
+				vault
+			),
+			driftProgram: this.driftClient.program.programId,
+			driftState: await this.driftClient.getStatePublicKey(),
+			driftSpotMarketVault: driftSpotMarket.vault,
+			userTokenAccount: getAssociatedTokenAddressSync(
+				driftSpotMarket.mint,
+				this.driftClient.wallet.publicKey
+			),
+			tokenProgram: TOKEN_PROGRAM_ID,
+		};
+
+		const { userTokenAccount, preIxs, postIxs } = await this.handleWSolMovement(
+			amount,
+			driftSpotMarket,
+			accounts.userTokenAccount
+		);
 
-		return await this.program.methods
-			.managerDeposit(amount)
-			.accounts({
-				vault,
-				vaultTokenAccount: vaultAccount.tokenAccount,
-				driftUser: await getUserAccountPublicKey(
-					this.driftClient.program.programId,
-					vault
-				),
-				driftProgram: this.driftClient.program.programId,
-				driftUserStats: getUserStatsAccountPublicKey(
-					this.driftClient.program.programId,
-					vault
-				),
-				driftState: await this.driftClient.getStatePublicKey(),
-				driftSpotMarketVault: driftSpotMarket.vault,
-				userTokenAccount: getAssociatedTokenAddressSync(
-					driftSpotMarket.mint,
-					this.driftClient.wallet.publicKey
-				),
-				tokenProgram: TOKEN_PROGRAM_ID,
-			})
-			.remainingAccounts(remainingAccounts)
-			.rpc();
+		if (this.cliMode) {
+			return await this.program.methods
+				.managerDeposit(amount)
+				.accounts({ ...accounts, userTokenAccount })
+				.remainingAccounts(remainingAccounts)
+				.preInstructions(preIxs)
+				.postInstructions(postIxs)
+				.rpc();
+		} else {
+			const managerDepositIx = await this.program.methods
+				.managerDeposit(amount)
+				.accounts({
+					...accounts,
+					userTokenAccount,
+					manager: this.driftClient.wallet.publicKey,
+				})
+				.remainingAccounts(remainingAccounts)
+				.instruction();
+			return await this.createAndSendTxn(
+				[...preIxs, managerDepositIx, ...postIxs],
+				uiTxParams
+			);
+		}
 	}
 
 	public async managerRequestWithdraw(
 		vault: PublicKey,
 		amount: BN,
-		withdrawUnit: WithdrawUnit
+		withdrawUnit: WithdrawUnit,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		this.program.idl.types;
 		// @ts-ignore
@@ -722,12 +832,13 @@ export class VaultClient {
 				}
 			);
 
-			return await this.createAndSendTxn([requestWithdrawIx]);
+			return await this.createAndSendTxn([requestWithdrawIx], uiTxParams);
 		}
 	}
 
 	public async managerCancelWithdrawRequest(
-		vault: PublicKey
+		vault: PublicKey,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultAccount = await this.program.account.vault.fetch(vault);
 
@@ -775,12 +886,13 @@ export class VaultClient {
 					remainingAccounts,
 				});
 
-			return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+			return await this.createAndSendTxn([cancelRequestWithdrawIx], uiTxParams);
 		}
 	}
 
 	public async managerWithdraw(
-		vault: PublicKey
+		vault: PublicKey,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultAccount = await this.program.account.vault.fetch(vault);
 
@@ -837,9 +949,7 @@ export class VaultClient {
 			},
 			remainingAccounts,
 		});
-		return this.createAndSendTxn([ix], {
-			cuLimit: 1_000_000,
-		});
+		return this.createAndSendTxn([ix], uiTxParams);
 	}
 
 	public async managerUpdateVault(
@@ -852,7 +962,8 @@ export class VaultClient {
 			profitShare: number | null;
 			hurdleRate: number | null;
 			permissioned: boolean | null;
-		}
+		},
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const ix = this.program.instruction.updateVault(params, {
 			accounts: {
@@ -860,10 +971,14 @@ export class VaultClient {
 				manager: this.driftClient.wallet.publicKey,
 			},
 		});
-		return this.createAndSendTxn([ix], {
-			cuLimit: 600_000,
-			cuPriceMicroLamports: 10_000,
-		});
+		if (this.cliMode) {
+			return this.createAndSendTxn([ix], {
+				cuLimit: 600_000,
+				cuPriceMicroLamports: 10_000,
+			});
+		} else {
+			return this.createAndSendTxn([ix], uiTxParams);
+		}
 	}
 
 	public async getApplyProfitShareIx(
@@ -1056,7 +1171,8 @@ export class VaultClient {
 	public async initializeVaultDepositor(
 		vault: PublicKey,
 		authority?: PublicKey,
-		payer?: PublicKey
+		payer?: PublicKey,
+		uiTxParams?: TxParams
 	): Promise<TransactionSignature> {
 		const vaultDepositor = getVaultDepositorAddressSync(
 			this.program.programId,
@@ -1082,7 +1198,7 @@ export class VaultClient {
 				.rpc();
 		} else {
 			const initIx = this.createInitVaultDepositorIx(vault, authority, payer);
-			return await this.createAndSendTxn([initIx]);
+			return await this.createAndSendTxn([initIx], uiTxParams);
 		}
 	}
 
@@ -1419,7 +1535,7 @@ export class VaultClient {
 			);
 		}
 
-		let userTokenAccount =
+		const nonWSolUserTokenAccount =
 			depositTokenAccount ??
 			getAssociatedTokenAddressSync(
 				spotMarket.mint,
@@ -1427,27 +1543,11 @@ export class VaultClient {
 				true
 			);
 
-		const isSolDeposit = spotMarket.mint.equals(WRAPPED_SOL_MINT);
-
-		const preIxs: TransactionInstruction[] = [];
-		const postIxs: TransactionInstruction[] = [];
-
-		if (isSolDeposit) {
-			const { ixs, pubkey } =
-				await this.driftClient.getWrappedSolAccountCreationIxs(amount, true);
-
-			userTokenAccount = pubkey;
-
-			preIxs.push(...ixs);
-			postIxs.push(
-				createCloseAccountInstruction(
-					userTokenAccount,
-					this.driftClient.wallet.publicKey,
-					this.driftClient.wallet.publicKey,
-					[]
-				)
-			);
-		}
+		const { userTokenAccount, preIxs, postIxs } = await this.handleWSolMovement(
+			amount,
+			spotMarket,
+			nonWSolUserTokenAccount
+		);
 
 		const accounts = {
 			vault: vaultPubKey,
@@ -1457,7 +1557,7 @@ export class VaultClient {
 			driftUser: vaultAccount.user,
 			driftState: driftStateKey,
 			driftSpotMarketVault: spotMarket.vault,
-			userTokenAccount,
+			userTokenAccount: userTokenAccount,
 			driftProgram: this.driftClient.program.programId,
 			tokenProgram: TOKEN_PROGRAM_ID,
 		};