@drift-labs/vaults-sdk 0.1.462 → 0.1.464

package/lib/vaultClient.js

@@ -8,6 +8,7 @@ const addresses_1 = require("./addresses");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const math_1 = require("./math");
 class VaultClient {
     constructor({ driftClient, program, cliMode, userMapConfig, }) {
         this.driftClient = driftClient;
@@ -27,8 +28,13 @@ class VaultClient {
             this.vaultUsers = new sdk_1.UserMap(userMapConfig);
         }
     }
+    /**
+     * Unsubscribes from the vault users map. Call this to clean up any dangling promises.
+     */
+    async unsubscribe() {
+        await this.vaultUsers.unsubscribe();
+    }
     async getVault(vault) {
-        // @ts-ignore
         return await this.program.account.vault.fetch(vault);
     }
     async getVaultAndSlot(vault) {
@@ -48,6 +54,19 @@ class VaultClient {
             slot: vaultDepositorAndSlot.context.slot,
         };
     }
+    getVaultProtocolAddress(vault) {
+        return (0, addresses_1.getVaultProtocolAddressSync)(this.program.programId, vault);
+    }
+    async getVaultProtocol(vaultProtocol) {
+        return await this.program.account.vaultProtocol.fetch(vaultProtocol);
+    }
+    async getVaultProtocolAndSlot(vaultProtocol) {
+        const vaultProtocolAndSlot = await this.program.account.vaultProtocol.fetchAndContext(vaultProtocol);
+        return {
+            vaultProtocol: vaultProtocolAndSlot.data,
+            slot: vaultProtocolAndSlot.context.slot,
+        };
+    }
     async getAllVaultDepositorsWithNoWithdrawRequest(vault) {
         const filters = [
             {
@@ -103,10 +122,16 @@ class VaultClient {
     /**
      *
      * @param vault pubkey
+     * @param factorUnrealizedPNL add unrealized pnl to net balance
      * @returns vault equity, in USDC
      */
     async calculateVaultEquity(params) {
         try {
+            // defaults to true if undefined
+            let factorUnrealizedPNL = true;
+            if (params.factorUnrealizedPNL !== undefined) {
+                factorUnrealizedPNL = params.factorUnrealizedPNL;
+            }
             let vaultAccount;
             if (params.address !== undefined) {
                 // @ts-ignore
@@ -120,8 +145,13 @@ class VaultClient {
             }
             const user = await this.getSubscribedVaultUser(vaultAccount.user);
             const netSpotValue = user.getNetSpotMarketValue();
-            const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
-            return netSpotValue.add(unrealizedPnl);
+            if (factorUnrealizedPNL) {
+                const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
+                return netSpotValue.add(unrealizedPnl);
+            }
+            else {
+                return netSpotValue;
+            }
         }
         catch (err) {
             console.error('VaultClient ~ err:', err);
@@ -131,12 +161,12 @@ class VaultClient {
     /**
      *
      * @param vault pubkey
-     * @returns vault equity, in spot deposit asset
+     * @param factorUnrealizedPNL add unrealized pnl to existing equity
+     * @returns total vault equity, in spot deposit asset
      */
     async calculateVaultEquityInDepositAsset(params) {
         let vaultAccount;
         if (params.address !== undefined) {
-            // @ts-ignore
             vaultAccount = await this.program.account.vault.fetch(params.address);
         }
         else if (params.vault !== undefined) {
@@ -147,13 +177,90 @@ class VaultClient {
         }
         const vaultEquity = await this.calculateVaultEquity({
             vault: vaultAccount,
+            factorUnrealizedPNL: params.factorUnrealizedPNL,
         });
         const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
         const spotOracle = this.driftClient.getOracleDataForSpotMarket(vaultAccount.spotMarketIndex);
         const spotPrecision = sdk_1.TEN.pow(new sdk_1.BN(spotMarket.decimals));
         return vaultEquity.mul(spotPrecision).div(spotOracle.price);
     }
+    /**
+     * @param params
+     * @returns vault depositor equity, in spot market value (which is usually USDC)
+     */
+    async calculateWithdrawableVaultDepositorEquity(params) {
+        let vaultAccount;
+        if (params.vaultAddress !== undefined) {
+            vaultAccount = await this.program.account.vault.fetch(params.vaultAddress);
+        }
+        else if (params.vault !== undefined) {
+            vaultAccount = params.vault;
+        }
+        else {
+            throw new Error('Must supply vaultAddress or vault');
+        }
+        let vaultDepositorAccount;
+        if (params.vaultDepositorAddress !== undefined) {
+            vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(params.vaultDepositorAddress);
+        }
+        else if (params.vaultDepositor !== undefined) {
+            vaultDepositorAccount = params.vaultDepositor;
+        }
+        else {
+            throw new Error('Must supply vaultDepositorAddress or vaultDepositor');
+        }
+        const vaultEquity = await this.calculateVaultEquity({
+            vault: vaultAccount,
+            factorUnrealizedPNL: false,
+        });
+        return (0, math_1.calculateRealizedVaultDepositorEquity)(vaultDepositorAccount, vaultEquity, vaultAccount);
+    }
+    async calculateWithdrawableVaultDepositorEquityInDepositAsset(params) {
+        let vaultAccount;
+        if (params.vaultAddress !== undefined) {
+            vaultAccount = await this.program.account.vault.fetch(params.vaultAddress);
+        }
+        else if (params.vault !== undefined) {
+            vaultAccount = params.vault;
+        }
+        else {
+            throw new Error('Must supply vaultAddress or vault');
+        }
+        let vaultDepositorAccount;
+        if (params.vaultDepositorAddress !== undefined) {
+            vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(params.vaultDepositorAddress);
+        }
+        else if (params.vaultDepositor !== undefined) {
+            vaultDepositorAccount = params.vaultDepositor;
+        }
+        else {
+            throw new Error('Must supply vaultDepositorAddress or vaultDepositor');
+        }
+        let vaultProtocol = undefined;
+        if (vaultAccount.vaultProtocol) {
+            vaultProtocol = await this.program.account.vaultProtocol.fetch(this.getVaultProtocolAddress(vaultAccount.pubkey));
+        }
+        const vaultEquity = await this.calculateVaultEquity({
+            vault: vaultAccount,
+            factorUnrealizedPNL: false,
+        });
+        const vdEquity = (0, math_1.calculateRealizedVaultDepositorEquity)(vaultDepositorAccount, vaultEquity, vaultAccount, vaultProtocol);
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        const spotOracle = this.driftClient.getOracleDataForSpotMarket(vaultAccount.spotMarketIndex);
+        const spotPrecision = sdk_1.TEN.pow(new sdk_1.BN(spotMarket.decimals));
+        return vdEquity.mul(spotPrecision).div(spotOracle.price);
+    }
+    async calculateVaultProtocolEquity(params) {
+        const vaultAccount = await this.program.account.vault.fetch(params.vault);
+        const vaultTotalEquity = await this.calculateVaultEquity({
+            vault: vaultAccount,
+        });
+        const vaultProtocol = this.getVaultProtocolAddress(params.vault);
+        const vpAccount = await this.program.account.vaultProtocol.fetch(vaultProtocol);
+        return (0, sdk_1.unstakeSharesToAmount)(vpAccount.protocolProfitAndFeeShares, vaultAccount.totalShares, vaultTotalEquity);
+    }
     async initializeVault(params) {
+        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);
         const driftState = await this.driftClient.getStatePublicKey();
@@ -173,18 +280,43 @@ class VaultClient {
             tokenAccount,
             driftProgram: this.driftClient.program.programId,
         };
-        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 (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();
+        }
+        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();
+        }
     }
     /**
      * Updates the delegate address for a vault. The delegate address will be allowed to trade
@@ -215,7 +347,7 @@ class VaultClient {
     /**
      * Updates the vault margin trading status.
      * @param vault vault address to update
-     * @param enabeld whether to enable margin trading
+     * @param enabled whether to enable margin trading
      * @returns
      */
     async updateMarginTradingEnabled(vault, enabled) {
@@ -246,6 +378,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         return await this.program.methods
             .managerDeposit(amount)
             .accounts({
@@ -274,6 +414,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
         const driftStateKey = await this.driftClient.getStatePublicKey();
         const accounts = {
@@ -318,6 +466,14 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         if (this.cliMode) {
             return await this.program.methods
                 .mangerCancelWithdrawRequest()
@@ -346,6 +502,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
         if (!spotMarket) {
             throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
@@ -466,6 +630,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultPubKey);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultPubKey);
         const driftStateKey = await this.driftClient.getStatePublicKey();
         const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
@@ -490,28 +662,38 @@ class VaultClient {
             remainingAccounts,
         };
     }
+    /**
+     * Creates a transaction to deposit funds into the specified vault.
+     * Uses the associated token account of the vault depositor authority and spot market mint,
+     * and assumes it exists before calling this function.
+     * @param vaultDepositor
+     * @param amount
+     * @param initVaultDepositor If true, will initialize the vault depositor account
+     * @returns transaction
+     */
     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,
-        });
+        const ixs = [];
         if (initVaultDepositor) {
-            const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
-            return await this.createTxn([initIx, depositIx], txParams);
-        }
-        else {
-            return await this.createTxn([depositIx], txParams);
+            ixs.push(this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority));
         }
+        const depositIx = await this.program.methods
+            .deposit(amount)
+            .accounts({
+            authority: this.driftClient.wallet.publicKey,
+            ...accounts,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        ixs.push(depositIx);
+        return await this.createTxn(ixs, txParams);
     }
     /**
      * Depositor funds into the specified vault.
      * @param vaultDepositor
      * @param amount
      * @param initVaultDepositor If true, will initialize the vault depositor account
+     * @param txParams
      * @returns
      */
     async deposit(vaultDepositor, amount, initVaultDepositor, txParams) {
@@ -538,6 +720,14 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
         const driftStateKey = await this.driftClient.getStatePublicKey();
         const accounts = {
@@ -577,6 +767,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
+        if (!vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
         const driftStateKey = await this.driftClient.getStatePublicKey();
         const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
@@ -603,21 +801,32 @@ class VaultClient {
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         if (this.cliMode) {
-            return await this.program.methods
-                .withdraw()
-                .accounts(accounts)
-                .remainingAccounts(remainingAccounts)
-                .rpc();
+            if (createAtaIx) {
+                return await this.program.methods
+                    .withdraw()
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .preInstructions([createAtaIx])
+                    .rpc();
+            }
+            else {
+                return await this.program.methods
+                    .withdraw()
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .rpc();
+            }
         }
         else {
             const ixs = [
-                this.program.instruction.withdraw({
-                    accounts: {
-                        authority: this.driftClient.wallet.publicKey,
-                        ...accounts,
-                    },
-                    remainingAccounts,
-                }),
+                await this.program.methods
+                    .withdraw()
+                    .accounts({
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                })
+                    .remainingAccounts(remainingAccounts)
+                    .instruction(),
             ];
             if (createAtaIx) {
                 ixs.unshift(createAtaIx);
@@ -636,6 +845,14 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
         const driftStateKey = await this.driftClient.getStatePublicKey();
         const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
@@ -697,6 +914,14 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
         if (this.cliMode) {
             return await this.program.methods
                 .cancelRequestWithdraw()
@@ -860,5 +1085,138 @@ class VaultClient {
         })
             .rpc();
     }
+    async protocolRequestWithdraw(vault, amount, withdrawUnit) {
+        // @ts-ignore
+        const vaultAccount = (await this.program.account.vault.fetch(vault));
+        const vp = this.getVaultProtocolAddress(vault);
+        const vpAccount = (await this.program.account.vaultProtocol.fetch(vp));
+        if (!this.driftClient.wallet.publicKey.equals(vpAccount.protocol)) {
+            throw new Error(`Only the protocol of the vault can request a withdraw.`);
+        }
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                // @ts-ignore, 0.29.0 anchor issues..
+                .managerRequestWithdraw(amount, withdrawUnit)
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(
+            // @ts-ignore
+            amount, withdrawUnit, {
+                accounts: {
+                    manager: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([requestWithdrawIx]);
+        }
+    }
+    async protocolCancelWithdrawRequest(vault) {
+        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();
+        const accounts = {
+            manager: this.driftClient.wallet.publicKey,
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+        });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        if (this.cliMode) {
+            return await this.program.methods
+                .mangerCancelWithdrawRequest()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
+        }
+        else {
+            const cancelRequestWithdrawIx = this.program.instruction.mangerCancelWithdrawRequest({
+                accounts: {
+                    ...accounts,
+                    manager: this.driftClient.wallet.publicKey,
+                },
+                remainingAccounts,
+            });
+            return await this.createAndSendTxn([cancelRequestWithdrawIx]);
+        }
+    }
+    async protocolWithdraw(vault) {
+        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.`);
+        }
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const ix = this.program.instruction.managerWithdraw({
+            accounts: {
+                vault,
+                manager: this.driftClient.wallet.publicKey,
+                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),
+                driftState: await this.driftClient.getStatePublicKey(),
+                driftSpotMarketVault: spotMarket.vault,
+                userTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey),
+                driftSigner: this.driftClient.getStateAccount().signer,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+        return this.createAndSendTxn([ix], {
+            cuLimit: 1000000,
+        });
+    }
 }
 exports.VaultClient = VaultClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/vaults-sdk",
-  "version": "0.1.462",
+  "version": "0.1.464",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "directories": {
@@ -9,7 +9,7 @@
   "dependencies": {
     "@coral-xyz/anchor": "0.28.0",
     "@drift-labs/competitions-sdk": "0.2.386",
-    "@drift-labs/sdk": "2.96.0-beta.9",
+    "@drift-labs/sdk": "2.96.0-beta.11",
     "@solana/web3.js": "1.92.3",
     "commander": "^11.0.0",
     "dotenv": "^16.3.1",