@drift-labs/vaults-sdk 0.1.334 → 0.1.335

package/lib/vaultClient.d.ts

@@ -2,7 +2,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 { AddressLookupTableAccount, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
 import { Vault, VaultDepositor, WithdrawUnit } from './types/types';
 import { UserMapConfig } from '@drift-labs/sdk/lib/userMap/userMapConfig';
 export type TxParams = {
@@ -110,6 +110,68 @@ export declare class VaultClient {
      * @returns
      */
     initializeVaultDepositor(vault: PublicKey, authority?: PublicKey): Promise<TransactionSignature>;
+    prepDepositTx(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
+        authority: PublicKey;
+        vault: PublicKey;
+    }): Promise<{
+        vaultAccount: {
+            name: number[];
+            pubkey: PublicKey;
+            manager: PublicKey;
+            tokenAccount: PublicKey;
+            userStats: PublicKey;
+            user: PublicKey;
+            delegate: PublicKey;
+            liquidationDelegate: PublicKey;
+            userShares: BN;
+            totalShares: BN;
+            lastFeeUpdateTs: BN;
+            liquidationStartTs: BN;
+            redeemPeriod: BN;
+            totalWithdrawRequested: BN;
+            maxTokens: BN;
+            managementFee: BN;
+            initTs: BN;
+            netDeposits: BN;
+            managerNetDeposits: BN;
+            totalDeposits: BN;
+            totalWithdraws: BN;
+            managerTotalDeposits: BN;
+            managerTotalWithdraws: BN;
+            managerTotalFee: BN;
+            managerTotalProfitShare: BN;
+            minDepositAmount: BN;
+            lastManagerWithdrawRequest: {
+                shares: BN;
+                value: BN;
+                ts: BN;
+            };
+            sharesBase: number;
+            profitShare: number;
+            hurdleRate: number;
+            spotMarketIndex: number;
+            bump: number;
+            permissioned: boolean;
+            padding: BN[];
+        };
+        accounts: {
+            vault: PublicKey;
+            vaultDepositor: PublicKey;
+            vaultTokenAccount: PublicKey;
+            driftUserStats: PublicKey;
+            driftUser: PublicKey;
+            driftState: PublicKey;
+            driftSpotMarketVault: PublicKey;
+            userTokenAccount: PublicKey;
+            driftProgram: PublicKey;
+            tokenProgram: PublicKey;
+        };
+        remainingAccounts: import("@solana/web3.js").AccountMeta[];
+    }>;
+    createDepositTx(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
+        authority: PublicKey;
+        vault: PublicKey;
+    }, txParams?: TxParams): Promise<VersionedTransaction>;
     /**
      * Depositor funds into the specified vault.
      * @param vaultDepositor
@@ -132,6 +194,8 @@ export declare class VaultClient {
      * @returns
      */
     liquidate(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    createTxn(vaultIxs: TransactionInstruction[], txParams?: TxParams): Promise<VersionedTransaction>;
+    sendTxn(transaction: VersionedTransaction, simulateTransaction?: boolean): Promise<TransactionSignature>;
     /**
      * Used for UI wallet adapters compatibility
      */

package/lib/vaultClient.js

@@ -269,7 +269,9 @@ class VaultClient {
                 .rpc();
         }
         else {
-            const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(amount, withdrawUnit, {
+            const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(
+            // @ts-ignore
+            amount, withdrawUnit, {
                 accounts: {
                     manager: this.driftClient.wallet.publicKey,
                     ...accounts,
@@ -427,14 +429,7 @@ class VaultClient {
             return await this.createAndSendTxn([initIx]);
         }
     }
-    /**
-     * Depositor funds into the specified vault.
-     * @param vaultDepositor
-     * @param amount
-     * @param initVaultDepositor If true, will initialize the vault depositor account
-     * @returns
-     */
-    async deposit(vaultDepositor, amount, initVaultDepositor, txParams) {
+    async prepDepositTx(vaultDepositor, amount, initVaultDepositor) {
         let vaultPubKey;
         if (initVaultDepositor) {
             vaultPubKey = initVaultDepositor.vault;
@@ -467,7 +462,39 @@ class VaultClient {
             driftProgram: this.driftClient.program.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
+        return {
+            vaultAccount,
+            accounts,
+            remainingAccounts,
+        };
+    }
+    async createDepositTx(vaultDepositor, amount, initVaultDepositor, txParams) {
+        const { vaultAccount, accounts, remainingAccounts } = await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor);
+        const depositIx = this.program.instruction.deposit(amount, {
+            accounts: {
+                authority: this.driftClient.wallet.publicKey,
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+        if (initVaultDepositor) {
+            const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
+            return await this.createTxn([initIx, depositIx], txParams);
+        }
+        else {
+            return await this.createTxn([depositIx], txParams);
+        }
+    }
+    /**
+     * Depositor funds into the specified vault.
+     * @param vaultDepositor
+     * @param amount
+     * @param initVaultDepositor If true, will initialize the vault depositor account
+     * @returns
+     */
+    async deposit(vaultDepositor, amount, initVaultDepositor, txParams) {
         if (this.cliMode) {
+            const { vaultAccount, accounts, remainingAccounts } = await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor);
             if (initVaultDepositor) {
                 await this.initializeVaultDepositor(vaultAccount.pubkey, initVaultDepositor.authority);
             }
@@ -478,20 +505,8 @@ class VaultClient {
                 .rpc();
         }
         else {
-            const depositIx = this.program.instruction.deposit(amount, {
-                accounts: {
-                    authority: this.driftClient.wallet.publicKey,
-                    ...accounts,
-                },
-                remainingAccounts,
-            });
-            if (initVaultDepositor) {
-                const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
-                return await this.createAndSendTxn([initIx, depositIx], txParams);
-            }
-            else {
-                return await this.createAndSendTxn([depositIx], txParams);
-            }
+            const depositTxn = await this.createDepositTx(vaultDepositor, amount, initVaultDepositor, txParams);
+            return this.sendTxn(depositTxn, txParams === null || txParams === void 0 ? void 0 : txParams.simulateTransaction);
         }
     }
     async requestWithdraw(vaultDepositor, amount, withdrawUnit, txParams) {
@@ -519,7 +534,9 @@ class VaultClient {
                 .rpc();
         }
         else {
-            const requestWithdrawIx = this.program.instruction.requestWithdraw(amount, withdrawUnit, {
+            const requestWithdrawIx = this.program.instruction.requestWithdraw(
+            // @ts-ignore
+            amount, withdrawUnit, {
                 accounts: {
                     authority: this.driftClient.wallet.publicKey,
                     ...accounts,
@@ -720,11 +737,8 @@ class VaultClient {
             return await this.createAndSendTxn([liquidateIx], txParams);
         }
     }
-    /**
-     * Used for UI wallet adapters compatibility
-     */
-    async createAndSendTxn(vaultIxs, txParams) {
-        var _a, _b, _c, _d;
+    async createTxn(vaultIxs, txParams) {
+        var _a, _b, _c;
         const ixs = [
             web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
                 units: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.cuLimit) !== null && _a !== void 0 ? _a : 400000,
@@ -734,7 +748,7 @@ class VaultClient {
             }),
             ...vaultIxs,
         ];
-        const tx = (await this.driftClient.txHandler.buildTransaction({
+        return (await this.driftClient.txHandler.buildTransaction({
             connection: this.driftClient.connection,
             instructions: ixs,
             lookupTables: (_c = txParams === null || txParams === void 0 ? void 0 : txParams.lookupTables) !== null && _c !== void 0 ? _c : [],
@@ -743,10 +757,13 @@ class VaultClient {
             txVersion: 0,
             fetchMarketLookupTableAccount: this.driftClient.fetchMarketLookupTableAccount.bind(this.driftClient),
         }));
-        let txSig = bytes_1.bs58.encode(tx.signatures[0]);
-        if (txParams === null || txParams === void 0 ? void 0 : txParams.simulateTransaction) {
+    }
+    async sendTxn(transaction, simulateTransaction) {
+        var _a;
+        let txSig = bytes_1.bs58.encode(transaction.signatures[0]);
+        if (simulateTransaction) {
             try {
-                const resp = await this.driftClient.connection.simulateTransaction(tx, {
+                const resp = await this.driftClient.connection.simulateTransaction(transaction, {
                     sigVerify: false,
                     commitment: this.driftClient.connection.commitment,
                 });
@@ -754,11 +771,11 @@ class VaultClient {
             }
             catch (e) {
                 const err = e;
-                console.error(`Error simulating transaction: ${err.message}\n:${(_d = err.stack) !== null && _d !== void 0 ? _d : ''}`);
+                console.error(`Error simulating transaction: ${err.message}\n:${(_a = err.stack) !== null && _a !== void 0 ? _a : ''}`);
             }
         }
         else {
-            const resp = await this.driftClient.sendTransaction(tx, [], this.driftClient.opts);
+            const resp = await this.driftClient.sendTransaction(transaction, [], this.driftClient.opts);
             if (resp.txSig !== txSig) {
                 console.error(`Transaction signature mismatch with self calculated value: ${resp.txSig} !== ${txSig}`);
                 txSig = resp.txSig;
@@ -766,6 +783,14 @@ class VaultClient {
         }
         return txSig;
     }
+    /**
+     * Used for UI wallet adapters compatibility
+     */
+    async createAndSendTxn(vaultIxs, txParams) {
+        const tx = await this.createTxn(vaultIxs, txParams);
+        const txSig = await this.sendTxn(tx, txParams === null || txParams === void 0 ? void 0 : txParams.simulateTransaction);
+        return txSig;
+    }
     /**
      * Initializes an insurance fund stake for the vault.
      * @param vault vault address to update

package/package.json

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

package/src/vaultClient.ts

@@ -437,6 +437,7 @@ export class VaultClient {
 				.rpc();
 		} else {
 			const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(
+				// @ts-ignore
 				amount,
 				withdrawUnit,
 				{
@@ -681,22 +682,14 @@ export class VaultClient {
 		}
 	}
 
-	/**
-	 * Depositor funds into the specified vault.
-	 * @param vaultDepositor
-	 * @param amount
-	 * @param initVaultDepositor If true, will initialize the vault depositor account
-	 * @returns
-	 */
-	public async deposit(
+	public async prepDepositTx(
 		vaultDepositor: PublicKey,
 		amount: BN,
 		initVaultDepositor?: {
 			authority: PublicKey;
 			vault: PublicKey;
-		},
-		txParams?: TxParams
-	): Promise<TransactionSignature> {
+		}
+	) {
 		let vaultPubKey: PublicKey;
 		if (initVaultDepositor) {
 			vaultPubKey = initVaultDepositor.vault;
@@ -747,7 +740,64 @@ export class VaultClient {
 			tokenProgram: TOKEN_PROGRAM_ID,
 		};
 
+		return {
+			vaultAccount,
+			accounts,
+			remainingAccounts,
+		};
+	}
+
+	public async createDepositTx(
+		vaultDepositor: PublicKey,
+		amount: BN,
+		initVaultDepositor?: {
+			authority: PublicKey;
+			vault: PublicKey;
+		},
+		txParams?: TxParams
+	): Promise<VersionedTransaction> {
+		const { vaultAccount, accounts, remainingAccounts } =
+			await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor);
+
+		const depositIx = this.program.instruction.deposit(amount, {
+			accounts: {
+				authority: this.driftClient.wallet.publicKey,
+				...accounts,
+			},
+			remainingAccounts,
+		});
+
+		if (initVaultDepositor) {
+			const initIx = this.createInitVaultDepositorIx(
+				vaultAccount.pubkey,
+				initVaultDepositor.authority
+			);
+			return await this.createTxn([initIx, depositIx], txParams);
+		} else {
+			return await this.createTxn([depositIx], txParams);
+		}
+	}
+
+	/**
+	 * Depositor funds into the specified vault.
+	 * @param vaultDepositor
+	 * @param amount
+	 * @param initVaultDepositor If true, will initialize the vault depositor account
+	 * @returns
+	 */
+	public async deposit(
+		vaultDepositor: PublicKey,
+		amount: BN,
+		initVaultDepositor?: {
+			authority: PublicKey;
+			vault: PublicKey;
+		},
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
 		if (this.cliMode) {
+			const { vaultAccount, accounts, remainingAccounts } =
+				await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor);
+
 			if (initVaultDepositor) {
 				await this.initializeVaultDepositor(
 					vaultAccount.pubkey,
@@ -760,23 +810,14 @@ export class VaultClient {
 				.remainingAccounts(remainingAccounts)
 				.rpc();
 		} else {
-			const depositIx = this.program.instruction.deposit(amount, {
-				accounts: {
-					authority: this.driftClient.wallet.publicKey,
-					...accounts,
-				},
-				remainingAccounts,
-			});
+			const depositTxn = await this.createDepositTx(
+				vaultDepositor,
+				amount,
+				initVaultDepositor,
+				txParams
+			);
 
-			if (initVaultDepositor) {
-				const initIx = this.createInitVaultDepositorIx(
-					vaultAccount.pubkey,
-					initVaultDepositor.authority
-				);
-				return await this.createAndSendTxn([initIx, depositIx], txParams);
-			} else {
-				return await this.createAndSendTxn([depositIx], txParams);
-			}
+			return this.sendTxn(depositTxn, txParams?.simulateTransaction);
 		}
 	}
 
@@ -821,6 +862,7 @@ export class VaultClient {
 				.rpc();
 		} else {
 			const requestWithdrawIx = this.program.instruction.requestWithdraw(
+				// @ts-ignore
 				amount,
 				withdrawUnit,
 				{
@@ -1111,13 +1153,10 @@ export class VaultClient {
 		}
 	}
 
-	/**
-	 * Used for UI wallet adapters compatibility
-	 */
-	public async createAndSendTxn(
+	public async createTxn(
 		vaultIxs: TransactionInstruction[],
 		txParams?: TxParams
-	): Promise<TransactionSignature> {
+	): Promise<VersionedTransaction> {
 		const ixs = [
 			ComputeBudgetProgram.setComputeUnitLimit({
 				units: txParams?.cuLimit ?? 400_000,
@@ -1128,7 +1167,7 @@ export class VaultClient {
 			...vaultIxs,
 		];
 
-		const tx = (await this.driftClient.txHandler.buildTransaction({
+		return (await this.driftClient.txHandler.buildTransaction({
 			connection: this.driftClient.connection,
 			instructions: ixs,
 			lookupTables: txParams?.lookupTables ?? [],
@@ -1138,13 +1177,22 @@ export class VaultClient {
 			fetchMarketLookupTableAccount:
 				this.driftClient.fetchMarketLookupTableAccount.bind(this.driftClient),
 		})) as VersionedTransaction;
-		let txSig = bs58.encode(tx.signatures[0]);
-		if (txParams?.simulateTransaction) {
+	}
+
+	public async sendTxn(
+		transaction: VersionedTransaction,
+		simulateTransaction?: boolean
+	): Promise<TransactionSignature> {
+		let txSig = bs58.encode(transaction.signatures[0]);
+		if (simulateTransaction) {
 			try {
-				const resp = await this.driftClient.connection.simulateTransaction(tx, {
-					sigVerify: false,
-					commitment: this.driftClient.connection.commitment,
-				});
+				const resp = await this.driftClient.connection.simulateTransaction(
+					transaction,
+					{
+						sigVerify: false,
+						commitment: this.driftClient.connection.commitment,
+					}
+				);
 				console.log(`Simulated transaction:\n${JSON.stringify(resp, null, 2)}`);
 			} catch (e) {
 				const err = e as Error;
@@ -1154,7 +1202,7 @@ export class VaultClient {
 			}
 		} else {
 			const resp = await this.driftClient.sendTransaction(
-				tx,
+				transaction,
 				[],
 				this.driftClient.opts
 			);
@@ -1169,6 +1217,19 @@ export class VaultClient {
 		return txSig!;
 	}
 
+	/**
+	 * Used for UI wallet adapters compatibility
+	 */
+	public async createAndSendTxn(
+		vaultIxs: TransactionInstruction[],
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const tx = await this.createTxn(vaultIxs, txParams);
+		const txSig = await this.sendTxn(tx, txParams?.simulateTransaction);
+
+		return txSig;
+	}
+
 	/**
 	 * Initializes an insurance fund stake for the vault.
 	 * @param vault vault address to update