@drift-labs/vaults-sdk 0.1.422 → 0.1.424

package/lib/vaultClient.js

@@ -8,7 +8,6 @@ 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;
@@ -28,13 +27,8 @@ 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) {
@@ -54,19 +48,6 @@ 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 = [
             {
@@ -122,16 +103,10 @@ 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
@@ -145,13 +120,8 @@ class VaultClient {
             }
             const user = await this.getSubscribedVaultUser(vaultAccount.user);
             const netSpotValue = user.getNetSpotMarketValue();
-            if (factorUnrealizedPNL) {
-                const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
-                return netSpotValue.add(unrealizedPnl);
-            }
-            else {
-                return netSpotValue;
-            }
+            const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
+            return netSpotValue.add(unrealizedPnl);
         }
         catch (err) {
             console.error('VaultClient ~ err:', err);
@@ -161,12 +131,12 @@ class VaultClient {
     /**
      *
      * @param vault pubkey
-     * @param factorUnrealizedPNL add unrealized pnl to existing equity
-     * @returns total vault equity, in spot deposit asset
+     * @returns 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) {
@@ -177,97 +147,13 @@ 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.equals(web3_js_1.SystemProgram.programId)) {
-            vaultProtocol = await this.program.account.vaultProtocol.fetch(vaultAccount.vaultProtocol);
-        }
-        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) {
-        // This is a workaround to make client backwards compatible.
-        // VaultProtocol is optionally undefined, but the anchor type is optionally null.
-        // Old clients will default to undefined which prevents old clients from having to pass in a null value.
-        // Instead, we can cast to null internally.
-        const _params = {
-            ...params,
-            vaultProtocol: params.vaultProtocol ? params.vaultProtocol : null,
-        };
         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();
@@ -287,43 +173,18 @@ class VaultClient {
             tokenAccount,
             driftProgram: this.driftClient.program.programId,
         };
-        if (params.vaultProtocol) {
-            const vaultProtocol = this.getVaultProtocolAddress((0, addresses_1.getVaultAddressSync)(this.program.programId, params.name));
-            const remainingAccounts = [
-                {
-                    pubkey: vaultProtocol,
-                    isSigner: false,
-                    isWritable: true,
-                },
-            ];
-            return await this.program.methods
-                .initializeVault(_params)
-                .preInstructions([
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 400000,
-                }),
-                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 300000,
-                }),
-            ])
-                .accounts(accounts)
-                .remainingAccounts(remainingAccounts)
-                .rpc();
-        }
-        else {
-            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();
-        }
+        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
@@ -354,7 +215,7 @@ class VaultClient {
     /**
      * Updates the vault margin trading status.
      * @param vault vault address to update
-     * @param enabled whether to enable margin trading
+     * @param enabeld whether to enable margin trading
      * @returns
      */
     async updateMarginTradingEnabled(vault, enabled) {
@@ -385,14 +246,6 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            const vaultProtocol = this.getVaultProtocolAddress(vault);
-            remainingAccounts.push({
-                pubkey: vaultProtocol,
-                isSigner: false,
-                isWritable: true,
-            });
-        }
         return await this.program.methods
             .managerDeposit(amount)
             .accounts({
@@ -421,14 +274,6 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            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 = {
@@ -473,14 +318,6 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            const vaultProtocol = this.getVaultProtocolAddress(vault);
-            remainingAccounts.push({
-                pubkey: vaultProtocol,
-                isSigner: false,
-                isWritable: true,
-            });
-        }
         if (this.cliMode) {
             return await this.program.methods
                 .mangerCancelWithdrawRequest()
@@ -509,14 +346,6 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            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`);
@@ -637,14 +466,6 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            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);
@@ -669,38 +490,28 @@ 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 ixs = [];
+        const depositIx = this.program.instruction.deposit(amount, {
+            accounts: {
+                authority: this.driftClient.wallet.publicKey,
+                ...accounts,
+            },
+            remainingAccounts,
+        });
         if (initVaultDepositor) {
-            ixs.push(this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority));
+            const initIx = this.createInitVaultDepositorIx(vaultAccount.pubkey, initVaultDepositor.authority);
+            return await this.createTxn([initIx, depositIx], txParams);
+        }
+        else {
+            return await this.createTxn([depositIx], txParams);
         }
-        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) {
@@ -727,14 +538,6 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            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 = {
@@ -774,14 +577,6 @@ 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);
@@ -808,32 +603,21 @@ class VaultClient {
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         if (this.cliMode) {
-            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();
-            }
+            return await this.program.methods
+                .withdraw()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .rpc();
         }
         else {
             const ixs = [
-                await this.program.methods
-                    .withdraw()
-                    .accounts({
-                    authority: this.driftClient.wallet.publicKey,
-                    ...accounts,
-                })
-                    .remainingAccounts(remainingAccounts)
-                    .instruction(),
+                this.program.instruction.withdraw({
+                    accounts: {
+                        authority: this.driftClient.wallet.publicKey,
+                        ...accounts,
+                    },
+                    remainingAccounts,
+                }),
             ];
             if (createAtaIx) {
                 ixs.unshift(createAtaIx);
@@ -852,14 +636,6 @@ class VaultClient {
             userAccounts: [user.getUserAccount()],
             writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            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);
@@ -921,14 +697,6 @@ class VaultClient {
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [user.getUserAccount()],
         });
-        if (!vaultAccount.vaultProtocol.equals(web3_js_1.SystemProgram.programId)) {
-            const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
-            remainingAccounts.push({
-                pubkey: vaultProtocol,
-                isSigner: false,
-                isWritable: true,
-            });
-        }
         if (this.cliMode) {
             return await this.program.methods
                 .cancelRequestWithdraw()
@@ -1092,138 +860,5 @@ 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.equals(web3_js_1.SystemProgram.programId)) {
-            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.equals(web3_js_1.SystemProgram.programId)) {
-            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.equals(web3_js_1.SystemProgram.programId)) {
-            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.422",
+  "version": "0.1.424",
   "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.94.0-beta.0",
+    "@drift-labs/sdk": "2.94.0-beta.1",
     "@solana/web3.js": "1.92.3",
     "commander": "^11.0.0",
     "dotenv": "^16.3.1",