@velocity-exchange/vaults-sdk 0.0.1 → 0.0.2

package/lib/vaultClient.js

@@ -0,0 +1,1914 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultClient = void 0;
+const sdk_1 = require("@velocity-exchange/sdk");
+const addresses_1 = require("./addresses");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("./types/types");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const math_1 = require("./math");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+class VaultClient {
+    constructor({ driftClient, program, metaplex, 
+    // @deprecated, no longer used
+    cliMode, userMapConfig, }) {
+        this.driftClient = driftClient;
+        this.metaplex = metaplex;
+        this.program = program;
+        this.cliMode = !!cliMode;
+        if (!userMapConfig) {
+            this.vaultUsers = new sdk_1.UserMap({
+                driftClient: driftClient,
+                subscriptionConfig: {
+                    type: 'polling',
+                    frequency: 1000,
+                    commitment: 'processed',
+                },
+            });
+        }
+        else {
+            this.vaultUsers = new sdk_1.UserMap(userMapConfig);
+        }
+    }
+    getRemainingAccountsForUser(userAccounts, writableSpotMarketIndexes, vaultAccount, _userStats, skipVaultProtocol = false, _skipFuelOverflow = false, skipFeeUpdate = false) {
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts,
+            writableSpotMarketIndexes,
+        });
+        const hasVaultProtocol = vaultAccount.vaultProtocol === true;
+        const hasFeeUpdate = (0, types_1.hasPendingFeeUpdate)(vaultAccount.feeUpdateStatus);
+        if (hasFeeUpdate && !skipFeeUpdate) {
+            const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vaultAccount.pubkey);
+            remainingAccounts.push({
+                pubkey: feeUpdate,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        if (hasVaultProtocol && !skipVaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultAccount.pubkey);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        return remainingAccounts;
+    }
+    async checkIfAccountExists(account) {
+        try {
+            const accountInfo = await this.driftClient.connection.getAccountInfo(account);
+            return accountInfo != null;
+        }
+        catch (e) {
+            // Doesn't already exist
+            return false;
+        }
+    }
+    /**
+     * Unsubscribes from the vault users map. Call this to clean up any dangling promises.
+     */
+    async unsubscribe() {
+        if (this.vaultUsers) {
+            await this.vaultUsers.unsubscribe();
+        }
+    }
+    async getVault(vault) {
+        return await this.program.account.vault.fetch(vault);
+    }
+    async getFeeUpdate(feeUpdate) {
+        return await this.program.account.feeUpdate.fetch(feeUpdate);
+    }
+    async getVaultAndSlot(vault) {
+        const vaultAndSlot = await this.program.account.vault.fetchAndContext(vault);
+        return {
+            vault: vaultAndSlot.data,
+            slot: vaultAndSlot.context.slot,
+        };
+    }
+    async getVaultDepositor(vaultDepositor) {
+        return await this.program.account.vaultDepositor.fetch(vaultDepositor);
+    }
+    async getVaultDepositorAndSlot(vaultDepositor) {
+        const vaultDepositorAndSlot = await this.program.account.vaultDepositor.fetchAndContext(vaultDepositor);
+        return {
+            vaultDepositor: vaultDepositorAndSlot.data,
+            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 = [
+            {
+                // discriminator = VaultDepositor
+                memcmp: {
+                    offset: 0,
+                    bytes: bytes_1.bs58.encode(this.program.coder.accounts.accountDiscriminator('vaultDepositor')),
+                },
+            },
+            {
+                // vault = vault
+                memcmp: {
+                    offset: 8,
+                    bytes: vault.toBase58(),
+                },
+            },
+            {
+                // last_withdraw_request.shares (u128) = 0
+                memcmp: {
+                    offset: 112,
+                    bytes: bytes_1.bs58.encode(new Uint8Array(16).fill(0)),
+                },
+            },
+        ];
+        // @ts-ignore
+        return (await this.program.account.vaultDepositor.all(filters));
+    }
+    async getAllVaultDepositors(vault) {
+        const filters = [
+            {
+                // discriminator = VaultDepositor
+                memcmp: {
+                    offset: 0,
+                    bytes: bytes_1.bs58.encode(this.program.coder.accounts.accountDiscriminator('vaultDepositor')),
+                },
+            },
+        ];
+        if (vault) {
+            filters.push({
+                // vault = vault
+                memcmp: {
+                    offset: 8,
+                    bytes: vault.toBase58(),
+                },
+            });
+        }
+        // @ts-ignore
+        return (await this.program.account.vaultDepositor.all(filters));
+    }
+    async getAllVaultDepositorsForAuthority(authority) {
+        const filters = [
+            {
+                // discriminator = VaultDepositor
+                memcmp: {
+                    offset: 0,
+                    bytes: bytes_1.bs58.encode(this.program.coder.accounts.accountDiscriminator('vaultDepositor')),
+                },
+            },
+        ];
+        filters.push({
+            // authority = authority
+            memcmp: {
+                offset: 8 + 32 + 32,
+                bytes: authority.toBase58(),
+            },
+        });
+        // @ts-ignore
+        return (await this.program.account.vaultDepositor.all(filters));
+    }
+    async getSubscribedVaultUser(vaultDriftUserAccountPubKey) {
+        return this.vaultUsers.mustGet(vaultDriftUserAccountPubKey.toBase58(), {
+            type: 'websocket',
+        });
+    }
+    /// useful for syncing state during tests.
+    async syncVaultUsers() {
+        for (const user of this.vaultUsers.values()) {
+            await user.fetchAccounts();
+        }
+    }
+    /**
+     *
+     * @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 includeManagerBorrowedValue = true;
+            if (params.includeManagerBorrowedValue !== undefined) {
+                includeManagerBorrowedValue = params.includeManagerBorrowedValue;
+            }
+            let vaultAccount;
+            if (params.address !== undefined) {
+                // @ts-ignore
+                vaultAccount = await this.program.account.vault.fetch(params.address);
+            }
+            else if (params.vault !== undefined) {
+                vaultAccount = params.vault;
+            }
+            else {
+                throw new Error('Must supply address or vault');
+            }
+            const user = await this.getSubscribedVaultUser(vaultAccount.user);
+            let netSpotValue = user.getNetSpotMarketValue();
+            if (factorUnrealizedPNL) {
+                const unrealizedPnl = user.getUnrealizedPNL(true, undefined, undefined);
+                netSpotValue = netSpotValue.add(unrealizedPnl);
+            }
+            if (includeManagerBorrowedValue) {
+                netSpotValue = netSpotValue.add(vaultAccount.managerBorrowedValue);
+            }
+            return netSpotValue;
+        }
+        catch (err) {
+            console.error('VaultClient ~ err:', err);
+            return sdk_1.ZERO;
+        }
+    }
+    async calculateVaultAllTimeNotionalPnl(params) {
+        try {
+            let vaultAccount;
+            if (params.address !== undefined) {
+                // @ts-ignore
+                vaultAccount = await this.program.account.vault.fetch(params.address);
+            }
+            else if (params.vault !== undefined) {
+                vaultAccount = params.vault;
+            }
+            else {
+                throw new Error('Must supply address or vault');
+            }
+            const user = await this.getSubscribedVaultUser(vaultAccount.user);
+            const allTimeTotalPnl = user.getTotalAllTimePnl();
+            return allTimeTotalPnl;
+        }
+        catch (err) {
+            console.error('VaultClient ~ err:', err);
+            return sdk_1.ZERO;
+        }
+    }
+    /**
+     *
+     * @param vault pubkey
+     * @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) {
+            vaultAccount = await this.program.account.vault.fetch(params.address);
+        }
+        else if (params.vault !== undefined) {
+            vaultAccount = params.vault;
+        }
+        else {
+            throw new Error('Must supply address or vault');
+        }
+        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, uiTxParams) {
+        const ix = await this.getInitializeVaultIx(params);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getInitializeVaultIx(params) {
+        var _a, _b, _c, _d;
+        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();
+        const spotMarket = this.driftClient.getSpotMarketAccount(params.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${params.spotMarketIndex} not found on driftClient`);
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userKey = (0, sdk_1.getUserAccountPublicKeySync)(this.driftClient.program.programId, vault);
+        const accounts = {
+            driftSpotMarket: spotMarket.pubkey,
+            driftSpotMarketMint: spotMarket.mint,
+            driftUserStats: userStatsKey,
+            driftUser: userKey,
+            driftState,
+            vault,
+            tokenAccount,
+            driftProgram: this.driftClient.program.programId,
+        };
+        if (vaultProtocolParams) {
+            const _params = {
+                ...vaultParams,
+                vaultProtocol: vaultProtocolParams,
+            };
+            const uiAuthority = this.driftClient.wallet.publicKey;
+            const initializeVaultWithProtocolIx = await this.program.methods
+                .initializeVaultWithProtocol(_params)
+                .accounts({
+                ...accounts,
+                payer: (_a = params.manager) !== null && _a !== void 0 ? _a : uiAuthority,
+                manager: (_b = params.manager) !== null && _b !== void 0 ? _b : uiAuthority,
+            })
+                .instruction();
+            return initializeVaultWithProtocolIx;
+        }
+        else {
+            const _params = vaultParams;
+            const uiAuthority = this.driftClient.wallet.publicKey;
+            const initializeVaultIx = await this.program.methods
+                .initializeVault(_params)
+                .accounts({
+                ...accounts,
+                payer: (_c = params.manager) !== null && _c !== void 0 ? _c : uiAuthority,
+                manager: (_d = params.manager) !== null && _d !== void 0 ? _d : uiAuthority,
+            })
+                .instruction();
+            return initializeVaultIx;
+        }
+    }
+    /**
+     * Updates the delegate address for a vault. The delegate address will be allowed to trade
+     * on behalf of the vault.
+     * @param vault vault address to update
+     * @param delegate delegate address to update to
+     * @returns
+     */
+    async updateDelegate(vault, delegate, uiTxParams) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const updateDelegateIx = await this.getUpdateDelegateIx(vault, delegate, vaultAccount.user, vaultAccount.manager);
+        return await this.createAndSendTxn([updateDelegateIx], uiTxParams);
+    }
+    async getUpdateDelegateIx(vault, delegate, vaultDriftUser, vaultManager) {
+        const accounts = {
+            vault: vault,
+            driftUser: vaultDriftUser,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return await this.program.methods
+            .updateDelegate(delegate)
+            .accounts({ ...accounts, manager: vaultManager })
+            .instruction();
+    }
+    /**
+     * Updates the vault margin trading status.
+     * @param vault vault address to update
+     * @param enabled whether to enable margin trading
+     * @returns
+     */
+    async updateMarginTradingEnabled(vault, enabled, uiTxParams) {
+        const updateMarginTradingEnabledIx = await this.getUpdateMarginTradingEnabledIx(vault, enabled);
+        return await this.createAndSendTxn([updateMarginTradingEnabledIx], uiTxParams);
+    }
+    async getUpdateMarginTradingEnabledIx(vault, enabled) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const accounts = {
+            vault: vault,
+            driftUser: vaultAccount.user,
+            driftProgram: this.driftClient.program.programId,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const remainingAccounts = [];
+        try {
+            const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+            const driftProgram = this.driftClient.program;
+            const userStats = (await driftProgram.account.userStats.fetch(userStatsKey));
+            remainingAccounts.push(...this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats));
+        }
+        catch (err) {
+            console.error('failed to get remaining accounts', err);
+            // do nothing
+        }
+        return await this.program.methods
+            .updateMarginTradingEnabled(enabled)
+            .accounts({ ...accounts, manager: vaultAccount.manager })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    /**
+     * Updates the vault's pool id (for isolated pools).
+     * @param vault vault address to update
+     * @param poolId pool id to update to
+     * @returns
+     */
+    async updateUserPoolId(vault, poolId, uiTxParams) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const updatePoolIdIx = await this.getUpdatePoolIdIx(vault, poolId, vaultAccount);
+        return await this.createAndSendTxn([updatePoolIdIx], uiTxParams);
+    }
+    /**
+     * Gets the instruction to update the pool id for a vault.
+     * @param vault vault address to update
+     * @param vaultAccount vault account data (optional, will be fetched if not provided)
+     * @param poolId pool id to update to
+     * @returns instruction to update pool id
+     */
+    async getUpdatePoolIdIx(vault, poolId, vaultAccount) {
+        if (!vaultAccount) {
+            vaultAccount = await this.program.account.vault.fetch(vault);
+        }
+        const accounts = {
+            vault: vault,
+            driftUser: vaultAccount.user,
+            driftProgram: this.driftClient.program.programId,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const remainingAccounts = [];
+        try {
+            const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+            const driftProgram = this.driftClient.program;
+            const userStats = (await driftProgram.account.userStats.fetch(userStatsKey));
+            remainingAccounts.push(...this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats));
+        }
+        catch (err) {
+            console.error('failed to get remaining accounts', err);
+            // do nothing
+        }
+        return await this.program.methods
+            .updateUserPoolId(poolId)
+            .accounts({ ...accounts, manager: vaultAccount.manager })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    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 };
+    }
+    /**
+     *
+     * @param vault vault address to deposit to
+     * @param amount amount to deposit
+     * @returns
+     */
+    async managerDeposit(vault, amount, uiTxParams, managerTokenAccount) {
+        const managerDepositIxs = await this.getManagerDepositIx(vault, amount, managerTokenAccount);
+        return await this.createAndSendTxn(managerDepositIxs, uiTxParams);
+    }
+    /**
+     *
+     * @param vault vault address to deposit to
+     * @param amount amount to deposit
+     * @returns
+     */
+    async getManagerDepositIx(vault, amount, managerTokenAccount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const driftSpotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!driftSpotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const accounts = {
+            vault,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftUserStats: (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftProgram: this.driftClient.program.programId,
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSpotMarketVault: driftSpotMarket.vault,
+            userTokenAccount: managerTokenAccount !== null && managerTokenAccount !== void 0 ? managerTokenAccount : (0, spl_token_1.getAssociatedTokenAddressSync)(driftSpotMarket.mint, vaultAccount.manager, true),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        const { userTokenAccount, preIxs, postIxs } = await this.handleWSolMovement(amount, driftSpotMarket, accounts.userTokenAccount);
+        const managerDepositIx = await this.program.methods
+            .managerDeposit(amount)
+            .accounts({
+            ...accounts,
+            userTokenAccount,
+            manager: vaultAccount.manager,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return [...preIxs, managerDepositIx, ...postIxs];
+    }
+    async managerRequestWithdraw(vault, amount, withdrawUnit, uiTxParams) {
+        const requestWithdrawIx = await this.getManagerRequestWithdrawIx(vault, amount, withdrawUnit);
+        return await this.createAndSendTxn([requestWithdrawIx], uiTxParams);
+    }
+    async getManagerRequestWithdrawIx(vault, amount, withdrawUnit) {
+        this.program.idl.types;
+        // @ts-ignore
+        const vaultAccount = (await this.program.account.vault.fetch(vault));
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const accounts = {
+            vault,
+            driftUser: vaultAccount.user,
+            driftUserStats: userStatsKey,
+        };
+        return this.program.instruction.managerRequestWithdraw(
+        // @ts-ignore
+        amount, withdrawUnit, {
+            accounts: {
+                manager: vaultAccount.manager,
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+    }
+    async managerCancelWithdrawRequest(vault, uiTxParams) {
+        const ix = await this.getManagerCancelWithdrawRequestIx(vault);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getManagerCancelWithdrawRequestIx(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const accounts = {
+            manager: vaultAccount.manager,
+            vault,
+            driftUser: vaultAccount.user,
+            driftUserStats: userStatsKey,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats, false, true, true);
+        return this.program.instruction.mangerCancelWithdrawRequest({
+            accounts,
+            remainingAccounts,
+        });
+    }
+    async managerWithdraw(vault, uiTxParams) {
+        const ixs = await this.getManagerWithdrawIx(vault);
+        return this.createAndSendTxn(ixs, uiTxParams);
+    }
+    async getManagerWithdrawIx(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const isSolMarket = spotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT);
+        let userAta = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vaultAccount.manager, true);
+        const preIxs = [];
+        const postIxs = [];
+        if (isSolMarket) {
+            const { ixs, pubkey } = await this.driftClient.getWrappedSolAccountCreationIxs(sdk_1.ZERO, false);
+            userAta = pubkey;
+            preIxs.push(...ixs);
+            postIxs.push((0, spl_token_1.createSyncNativeInstruction)(userAta));
+            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(userAta, vaultAccount.manager, vaultAccount.manager, []));
+        }
+        else {
+            const userAtaExists = await this.driftClient.connection.getAccountInfo(userAta);
+            if (userAtaExists === null) {
+                preIxs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(vaultAccount.manager, userAta, vaultAccount.manager, spotMarket.mint));
+            }
+        }
+        const withdrawIx = await this.program.instruction.managerWithdraw({
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+                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: userAta,
+                driftSigner: this.driftClient.getStateAccount().signer,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+        return [...preIxs, withdrawIx, ...postIxs];
+    }
+    async managerBorrow(vault, borrowSpotMarketIndex, borrowAmount, managerTokenAccount, txParams) {
+        const ixs = await this.getManagerBorrowIx(vault, borrowSpotMarketIndex, borrowAmount, managerTokenAccount);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async getManagerBorrowIx(vault, borrowSpotMarketIndex, borrowAmount, managerTokenAccount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const spotMarket = this.driftClient.getSpotMarketAccount(borrowSpotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${borrowSpotMarketIndex} not found on driftClient`);
+        }
+        if (!managerTokenAccount) {
+            managerTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true);
+        }
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [borrowSpotMarketIndex, vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const preIxs = [];
+        const postIxs = [];
+        const managerTokenAccountExists = await this.driftClient.connection.getAccountInfo(managerTokenAccount);
+        if (managerTokenAccountExists === null) {
+            preIxs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(vaultAccount.manager, managerTokenAccount, vaultAccount.manager, spotMarket.mint));
+        }
+        const vaultBorrowTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vault, true);
+        const vaultBorrowTokenAccountExists = await this.driftClient.connection.getAccountInfo(vaultBorrowTokenAccount);
+        if (vaultBorrowTokenAccountExists === null) {
+            preIxs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(this.driftClient.wallet.publicKey, vaultBorrowTokenAccount, vault, spotMarket.mint));
+        }
+        if (spotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT)) {
+            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(managerTokenAccount, vaultAccount.manager, vaultAccount.manager, []));
+        }
+        return [
+            ...preIxs,
+            await this.program.methods
+                .managerBorrow(borrowSpotMarketIndex, borrowAmount)
+                .accounts({
+                vault,
+                vaultTokenAccount: vaultBorrowTokenAccount,
+                manager: vaultAccount.manager,
+                driftUserStats: userStatsKey,
+                driftUser: vaultAccount.user,
+                driftState: await this.driftClient.getStatePublicKey(),
+                driftSpotMarketVault: spotMarket.vault,
+                driftSigner: this.driftClient.getStateAccount().signer,
+                userTokenAccount: managerTokenAccount,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction(),
+            ...postIxs,
+        ];
+    }
+    async managerRepay(vault, repaySpotMarketIndex, repayAmount, repayValue, managerTokenAccount, uiTxParams) {
+        const ixs = await this.getManagerRepayIxs(vault, repaySpotMarketIndex, repayAmount, repayValue, managerTokenAccount);
+        return this.createAndSendTxn(ixs, uiTxParams);
+    }
+    /**
+     * Get the instructions for the manager repay transaction
+     * @param vault - The vault to repay
+     * @param repaySpotMarketIndex - The spot market index to repay
+     * @param repayAmount - The amount to repay
+     * @param repayValue - The value of the repay
+     * @param managerTokenAccount - The manager token account to use, if depositing SOL, leave undefined to automatically wrap the SOL
+     * @returns The instructions for the manager repay transaction
+     */
+    async getManagerRepayIxs(vault, repaySpotMarketIndex, repayAmount, repayValue, managerTokenAccount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const spotMarket = this.driftClient.getSpotMarketAccount(repaySpotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${repaySpotMarketIndex} not found on driftClient`);
+        }
+        const isSolMarket = spotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT);
+        const preIxs = [];
+        const postIxs = [];
+        let createdWsolAccount = false;
+        if (!managerTokenAccount) {
+            if (isSolMarket) {
+                // create wSOL
+                const { ixs, pubkey } = await this.driftClient.getWrappedSolAccountCreationIxs(repayAmount, true);
+                preIxs.push(...ixs);
+                managerTokenAccount = pubkey;
+                createdWsolAccount = true;
+            }
+            else {
+                managerTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vaultAccount.manager, true);
+            }
+        }
+        const vaultRepayTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vault, true);
+        const vaultRepayTokenAccountExists = await this.driftClient.connection.getAccountInfo(vaultRepayTokenAccount);
+        if (vaultRepayTokenAccountExists === null) {
+            preIxs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(this.driftClient.wallet.publicKey, vaultRepayTokenAccount, vault, spotMarket.mint));
+        }
+        if (createdWsolAccount) {
+            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(managerTokenAccount, vaultAccount.manager, vaultAccount.manager, []));
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [repaySpotMarketIndex, vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        return [
+            ...preIxs,
+            await this.program.methods
+                .managerRepay(repaySpotMarketIndex, repayAmount, repayValue)
+                .accounts({
+                vault,
+                vaultTokenAccount: vaultRepayTokenAccount,
+                manager: vaultAccount.manager,
+                driftUserStats: userStatsKey,
+                driftUser: vaultAccount.user,
+                driftState: await this.driftClient.getStatePublicKey(),
+                driftSpotMarketVault: spotMarket.vault,
+                driftSigner: this.driftClient.getStateAccount().signer,
+                userTokenAccount: managerTokenAccount,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction(),
+            ...postIxs,
+        ];
+    }
+    async managerUpdateBorrow(vault, newBorrowValue, txParams) {
+        const ix = await this.getManagerUpdateBorrowIx(vault, newBorrowValue);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getManagerUpdateBorrowIx(vault, newBorrowValue) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats, false, false, false);
+        return this.program.instruction.managerUpdateBorrow(newBorrowValue, {
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+                driftUserStats: userStatsKey,
+                driftUser: vaultAccount.user,
+            },
+            remainingAccounts,
+        });
+    }
+    async managerUpdateVault(vault, params, uiTxParams) {
+        const ix = await this.getManagerUpdateVaultIx(vault, params);
+        return this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getManagerUpdateVaultIx(vault, params) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        return this.program.instruction.updateVault(params, {
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+            },
+        });
+    }
+    async managerUpdateVaultManager(vault, manager, uiTxParams) {
+        const ix = await this.getManagerUpdateVaultManagerIx(vault, manager);
+        return this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getManagerUpdateVaultManagerIx(vault, manager) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        return this.program.instruction.updateVaultManager(manager, {
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+            },
+        });
+    }
+    async applyProfitShare(vault, vaultDepositor, uiTxParams) {
+        const ix = await this.getApplyProfitShareIx(vault, vaultDepositor);
+        return this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getApplyProfitShareIx(vault, vaultDepositor) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const accounts = {
+            vault,
+            vaultDepositor,
+            manager: vaultAccount.manager,
+            driftUserStats: (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSigner: this.driftClient.getStateAccount().signer,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return this.program.instruction.applyProfitShare({
+            accounts: {
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+    }
+    async getApplyRebaseTokenizedDepositorIx(vault, tokenizedVaultDepositor) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const accounts = {
+            vault,
+            tokenizedVaultDepositor,
+            driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSigner: this.driftClient.getStateAccount().signer,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return this.program.instruction.applyRebaseTokenizedDepositor({
+            accounts: {
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+    }
+    async applyRebase(vault, vaultDepositor) {
+        return await this.createAndSendTxn([
+            await this.getApplyRebaseIx(vault, vaultDepositor),
+        ]);
+    }
+    async getApplyRebaseIx(vault, vaultDepositor) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const accounts = {
+            vault,
+            vaultDepositor,
+            driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSigner: this.driftClient.getStateAccount().signer,
+            driftProgram: this.driftClient.program.programId,
+        };
+        return this.program.instruction.applyRebase({
+            accounts: {
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+    }
+    async applyRebaseTokenizedDepositor(vault, tokenizedVaultDepositor) {
+        return await this.createAndSendTxn([
+            await this.getApplyRebaseTokenizedDepositorIx(vault, tokenizedVaultDepositor),
+        ]);
+    }
+    createInitVaultDepositorIx(vault, authority, payer) {
+        const vaultDepositor = (0, addresses_1.getVaultDepositorAddressSync)(this.program.programId, vault, authority || this.driftClient.wallet.publicKey);
+        const accounts = {
+            vaultDepositor,
+            vault,
+            authority: authority || this.driftClient.wallet.publicKey,
+        };
+        const initIx = this.program.instruction.initializeVaultDepositor({
+            accounts: {
+                ...accounts,
+                payer: payer || authority || this.driftClient.wallet.publicKey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+        });
+        return initIx;
+    }
+    /**
+     * Initializes the vault depositor account. This account is used to deposit funds into a vault.
+     * @param vault the vault address to deposit into
+     * @param authority the authority allowed to make deposits into the vault
+     * @returns
+     */
+    async initializeVaultDepositor(vault, authority, payer, uiTxParams) {
+        const initIx = this.createInitVaultDepositorIx(vault, authority, payer);
+        return await this.createAndSendTxn([initIx], uiTxParams);
+    }
+    async initializeTokenizedVaultDepositor(params, uiTxParams) {
+        var _a;
+        if (!this.metaplex) {
+            throw new Error('Metaplex instance is required when constructing VaultClient to initialize a tokenized vault depositor');
+        }
+        let spotMarketDecimals = 6;
+        let sharesBase = 0;
+        if (params.decimals === undefined || params.sharesBase === undefined) {
+            const vault = await this.program.account.vault.fetch(params.vault);
+            const spotMarketAccount = this.driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+            if (!spotMarketAccount) {
+                throw new Error(`DriftClient failed to load vault's spot market (marketIndex: ${vault.spotMarketIndex})`);
+            }
+            spotMarketDecimals = spotMarketAccount.decimals;
+            sharesBase = vault.sharesBase;
+        }
+        const mintAddress = (0, addresses_1.getTokenizedVaultMintAddressSync)(this.program.programId, params.vault, sharesBase);
+        const vaultAccount = await this.program.account.vault.fetch(params.vault);
+        const accounts = {
+            vault: params.vault,
+            vaultDepositor: (0, addresses_1.getTokenizedVaultAddressSync)(this.program.programId, params.vault, sharesBase),
+            mintAccount: mintAddress,
+            metadataAccount: this.metaplex.nfts().pdas().metadata({
+                mint: mintAddress,
+            }),
+            tokenMetadataProgram: this.metaplex.programs().getTokenMetadata().address,
+            payer: vaultAccount.manager,
+        };
+        const vaultTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mintAddress, params.vault, true);
+        const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(vaultAccount.manager, vaultTokenAta, params.vault, mintAddress);
+        return await this.createAndSendTxn([
+            await this.program.methods
+                .initializeTokenizedVaultDepositor({
+                ...params,
+                decimals: (_a = params.decimals) !== null && _a !== void 0 ? _a : spotMarketDecimals,
+            })
+                .accounts(accounts)
+                .instruction(),
+            createAtaIx,
+        ], uiTxParams);
+    }
+    async createTokenizeSharesIx(vaultDepositor, amount, unit, mint) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        mint =
+            mint !== null && mint !== void 0 ? mint : (0, addresses_1.getTokenizedVaultMintAddressSync)(this.program.programId, vaultDepositorAccount.vault, vaultAccount.sharesBase);
+        const userAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, this.driftClient.wallet.publicKey, true);
+        const ixs = [];
+        const userAtaExists = await this.driftClient.connection.getAccountInfo(userAta);
+        if (userAtaExists === null) {
+            ixs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(this.driftClient.wallet.publicKey, userAta, this.driftClient.wallet.publicKey, mint));
+        }
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        ixs.push(await this.program.methods
+            // anchor idl bug: https://github.com/coral-xyz/anchor/issues/2914
+            // @ts-ignore args tuple vs anchor 0.32 IDL recursion limit
+            .tokenizeShares(amount, unit)
+            // `mint` is auto-resolved from IDL seeds, but anchor 1.0's IDL
+            // generator can't encode `vault.shares_base.to_string().as_bytes()`
+            // and emits broken seeds. Pass it explicitly to override.
+            .accountsPartial({
+            authority: this.driftClient.wallet.publicKey,
+            vault: vaultDepositorAccount.vault,
+            tokenizedVaultDepositor: (0, addresses_1.getTokenizedVaultAddressSync)(this.program.programId, vaultDepositorAccount.vault, vaultAccount.sharesBase),
+            mint,
+            userTokenAccount: userAta,
+            driftUser: vaultAccount.user,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction());
+        return ixs;
+    }
+    async tokenizeShares(vaultDepositor, amount, unit, mint, txParams) {
+        const ixs = await this.createTokenizeSharesIx(vaultDepositor, amount, unit, mint);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async createTransferVaultDepositorSharesIx(fromVaultDepositor, toVaultDepositor, amount, withdrawUnit) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(fromVaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const ixs = [];
+        ixs.push(await this.program.methods
+            // @ts-ignore args tuple vs anchor 0.32 IDL recursion limit
+            .transferVaultDepositorShares(amount, withdrawUnit)
+            .accounts({
+            vault: vaultDepositorAccount.vault,
+            authority: this.driftClient.wallet.publicKey,
+            toVaultDepositor,
+            driftUser: vaultAccount.user,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction());
+        return ixs;
+    }
+    async transferVaultDepositorShares(fromVaultDepositor, toVaultDepositor, amount, withdrawUnit, txParams) {
+        const ixs = await this.createTransferVaultDepositorSharesIx(fromVaultDepositor, toVaultDepositor, amount, withdrawUnit);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async createRedeemTokensIx(vaultDepositor, tokensToBurn, sharesBase) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const mint = (0, addresses_1.getTokenizedVaultMintAddressSync)(this.program.programId, vaultDepositorAccount.vault, sharesBase !== null && sharesBase !== void 0 ? sharesBase : vaultAccount.sharesBase);
+        const userAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, this.driftClient.wallet.publicKey, true);
+        const vaultTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, vaultDepositorAccount.vault, true);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        return await this.program.methods
+            .redeemTokens(tokensToBurn)
+            .accounts({
+            authority: this.driftClient.wallet.publicKey,
+            vault: vaultDepositorAccount.vault,
+            tokenizedVaultDepositor: (0, addresses_1.getTokenizedVaultAddressSync)(this.program.programId, vaultDepositorAccount.vault, sharesBase !== null && sharesBase !== void 0 ? sharesBase : vaultAccount.sharesBase),
+            mint,
+            userTokenAccount: userAta,
+            vaultTokenAccount: vaultTokenAta,
+            driftUser: vaultAccount.user,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    /**
+     * Redeems tokens from the vault.
+     * @param vaultDepositor
+     * @param tokensToBurn
+     * @param mint optionally provide a mint, or infer the mint from the current vault share base
+     * @param txParams
+     * @returns
+     */
+    async redeemTokens(vaultDepositor, tokensToBurn, sharesBase, txParams) {
+        const ix = await this.createRedeemTokensIx(vaultDepositor, tokensToBurn, sharesBase);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async prepDepositTx(vaultDepositor, amount, initVaultDepositor, depositTokenAccount) {
+        let vaultPubKey;
+        if (initVaultDepositor) {
+            vaultPubKey = initVaultDepositor.vault;
+        }
+        else {
+            const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+            vaultPubKey = vaultDepositorAccount.vault;
+        }
+        const vaultAccount = await this.program.account.vault.fetch(vaultPubKey);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultPubKey);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        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,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftSpotMarketVault: spotMarket.vault,
+            userTokenAccount: userTokenAccount,
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        return {
+            vaultAccount,
+            accounts,
+            remainingAccounts,
+            preIxs,
+            postIxs,
+        };
+    }
+    /**
+     * 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, userTokenAccount) {
+        const { vaultAccount, accounts, remainingAccounts, preIxs, postIxs } = await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor, userTokenAccount);
+        const ixs = [];
+        if (initVaultDepositor) {
+            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(...preIxs);
+        ixs.push(depositIx);
+        ixs.push(...postIxs);
+        if ((txParams === null || txParams === void 0 ? void 0 : txParams.noLut) ? txParams.noLut : false) {
+            return await this.createTxnNoLut(ixs, txParams);
+        }
+        else {
+            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, userTokenAccount) {
+        const depositTxn = await this.createDepositTx(vaultDepositor, amount, initVaultDepositor, txParams, userTokenAccount);
+        return this.sendTxn(depositTxn, txParams === null || txParams === void 0 ? void 0 : txParams.simulateTransaction);
+    }
+    async requestWithdraw(vaultDepositor, amount, withdrawUnit, txParams) {
+        const ixs = await this.getRequestWithdrawIx(vaultDepositor, amount, withdrawUnit, txParams === null || txParams === void 0 ? void 0 : txParams.oracleFeedsToCrank);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async getRequestWithdrawIx(vaultDepositor, amount, withdrawUnit, oracleFeedsToCrank) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            driftUser: vaultAccount.user,
+            driftUserStats: userStatsKey,
+        };
+        const oracleFeedsToCrankIxs = await this.getOracleFeedsToCrankIxs(oracleFeedsToCrank);
+        const requestWithdrawIx = this.program.instruction.requestWithdraw(
+        // @ts-ignore
+        amount, withdrawUnit, {
+            accounts: {
+                authority: this.driftClient.wallet.publicKey,
+                ...accounts,
+            },
+            remainingAccounts,
+        });
+        return [...oracleFeedsToCrankIxs, requestWithdrawIx];
+    }
+    async withdraw(vaultDepositor, txParams) {
+        const ixs = await this.getWithdrawIx(vaultDepositor, txParams === null || txParams === void 0 ? void 0 : txParams.oracleFeedsToCrank);
+        return await this.createAndSendTxn(ixs, {
+            cuLimit: 850000, // overestimating to be safe
+            ...txParams,
+        });
+    }
+    async getWithdrawIx(vaultDepositor, oracleFeedsToCrank) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const isSolMarket = spotMarket.mint.equals(sdk_1.WRAPPED_SOL_MINT);
+        // let createAtaIx: TransactionInstruction | undefined = undefined;
+        let userAta = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true);
+        const preIxs = [];
+        const postIxs = [];
+        if (isSolMarket) {
+            const { ixs, pubkey } = await this.driftClient.getWrappedSolAccountCreationIxs(sdk_1.ZERO, false);
+            userAta = pubkey;
+            preIxs.push(...ixs);
+            postIxs.push((0, spl_token_1.createSyncNativeInstruction)(userAta));
+            postIxs.push((0, spl_token_1.createCloseAccountInstruction)(userAta, this.driftClient.wallet.publicKey, this.driftClient.wallet.publicKey, []));
+        }
+        else {
+            const userAtaExists = await this.driftClient.connection.getAccountInfo(userAta);
+            if (userAtaExists === null) {
+                preIxs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(this.driftClient.wallet.publicKey, userAta, this.driftClient.wallet.publicKey, spotMarket.mint));
+            }
+        }
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftSpotMarketVault: spotMarket.vault,
+            driftSigner: this.driftClient.getStateAccount().signer,
+            userTokenAccount: userAta,
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        const oracleFeedsToCrankIxs = await this.getOracleFeedsToCrankIxs(oracleFeedsToCrank);
+        const ixs = [
+            ...oracleFeedsToCrankIxs,
+            ...preIxs,
+            await this.program.methods
+                .withdraw()
+                .accounts({
+                authority: this.driftClient.wallet.publicKey,
+                ...accounts,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction(),
+            ...postIxs,
+        ];
+        return ixs;
+    }
+    async forceWithdraw(vaultDepositor, txParams) {
+        const ix = await this.getForceWithdrawIx(vaultDepositor);
+        return await this.createAndSendTxn(ix, txParams);
+    }
+    async getForceWithdrawIx(vaultDepositor) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        if (vaultAccount.vaultProtocol) {
+            const vaultProtocol = this.getVaultProtocolAddress(vaultDepositorAccount.vault);
+            remainingAccounts.push({
+                pubkey: vaultProtocol,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${vaultAccount.spotMarketIndex} not found on driftClient`);
+        }
+        const [userTokenAccount, createAtaIx] = await (0, utils_1.getOrCreateATAInstruction)(spotMarket.mint, vaultDepositorAccount.authority, this.driftClient.connection, true, this.driftClient.wallet.publicKey);
+        if (createAtaIx) {
+            console.log(`Creating ATA for ${vaultDepositorAccount.authority.toBase58()} to ${userTokenAccount.toBase58()}`);
+        }
+        const accounts = {
+            manager: vaultAccount.manager,
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftSpotMarketVault: spotMarket.vault,
+            driftSigner: this.driftClient.getStateAccount().signer,
+            userTokenAccount,
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        };
+        const ixs = [];
+        if (createAtaIx) {
+            ixs.push(createAtaIx);
+        }
+        ixs.push(await this.program.methods
+            .forceWithdraw()
+            .accounts(accounts)
+            .remainingAccounts(remainingAccounts)
+            .instruction());
+        return ixs;
+    }
+    async cancelRequestWithdraw(vaultDepositor, txParams) {
+        const ixs = await this.getCancelRequestWithdrawIx(vaultDepositor, txParams === null || txParams === void 0 ? void 0 : txParams.oracleFeedsToCrank);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async getCancelRequestWithdrawIx(vaultDepositor, oracleFeedsToCrank) {
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vaultAccount = await this.program.account.vault.fetch(vaultDepositorAccount.vault);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vaultDepositorAccount.vault);
+        const accounts = {
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, false, false);
+        if (this.cliMode) {
+            return [
+                await this.program.methods
+                    .cancelRequestWithdraw()
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .instruction(),
+            ];
+        }
+        else {
+            const oracleFeedsToCrankIxs = await this.getOracleFeedsToCrankIxs(oracleFeedsToCrank);
+            const cancelRequestWithdrawIx = this.program.instruction.cancelRequestWithdraw({
+                accounts: {
+                    authority: this.driftClient.wallet.publicKey,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return [...oracleFeedsToCrankIxs, cancelRequestWithdrawIx];
+        }
+    }
+    /**
+     * Liquidates (become delegate for) a vault.
+     * @param
+     * @param
+     * @returns
+     */
+    async liquidate(vaultDepositor, txParams) {
+        const ix = await this.getLiquidateIx(vaultDepositor);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getLiquidateIx(vaultDepositor) {
+        if (!this.driftClient.wallet.publicKey.equals(constants_1.VAULT_ADMIN_KEY)) {
+            throw new Error('Only vault admin can liquidate');
+        }
+        const vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
+        const vault = vaultDepositorAccount.vault;
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [vaultAccount.spotMarketIndex], vaultAccount, userStats, false, true, true);
+        const driftStateKey = await this.driftClient.getStatePublicKey();
+        const accounts = {
+            vault,
+            vaultDepositor,
+            vaultTokenAccount: vaultAccount.tokenAccount,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+            driftState: driftStateKey,
+            driftProgram: this.driftClient.program.programId,
+            authority: vaultDepositorAccount.authority,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                .liquidate()
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+        }
+        else {
+            return this.program.instruction.liquidate({
+                accounts: {
+                    ...accounts,
+                    admin: this.driftClient.wallet.publicKey,
+                },
+                remainingAccounts,
+            });
+        }
+    }
+    async createTxn(vaultIxs, txParams) {
+        var _a, _b;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.cuLimit) !== null && _a !== void 0 ? _a : 400000,
+            }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: (txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) === undefined
+                    ? 50000
+                    : txParams.cuPriceMicroLamports,
+            }),
+            ...vaultIxs,
+        ];
+        return (await this.driftClient.txHandler.buildTransaction({
+            connection: this.driftClient.connection,
+            instructions: ixs,
+            lookupTables: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.lookupTables) !== null && _b !== void 0 ? _b : [],
+            preFlightCommitment: 'confirmed',
+            forceVersionedTransaction: true,
+            txVersion: 0,
+            fetchAllMarketLookupTableAccounts: this.driftClient.fetchAllLookupTableAccounts.bind(this.driftClient),
+        }));
+    }
+    async createTxnNoLut(vaultIxs, txParams) {
+        var _a;
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.cuLimit) !== null && _a !== void 0 ? _a : 400000,
+            }),
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: (txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) === undefined
+                    ? 50000
+                    : txParams.cuPriceMicroLamports,
+            }),
+            ...vaultIxs,
+        ];
+        const recentBlockhash = await this.driftClient.connection.getLatestBlockhash();
+        return this.driftClient.txHandler.generateVersionedTransaction(recentBlockhash, ixs, [], this.driftClient.wallet);
+    }
+    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(transaction, {
+                    sigVerify: false,
+                    commitment: this.driftClient.connection.commitment,
+                });
+                console.log(`Simulated transaction:\n${JSON.stringify(resp, null, 2)}`);
+            }
+            catch (e) {
+                const err = e;
+                console.error(`Error simulating transaction: ${err.message}\n:${(_a = err.stack) !== null && _a !== void 0 ? _a : ''}`);
+            }
+        }
+        else {
+            const resp = await this.driftClient.sendTransaction(transaction, [], this.driftClient.opts);
+            if (resp.txSig !== txSig) {
+                txSig = resp.txSig;
+            }
+        }
+        return txSig;
+    }
+    /**
+     * Used for UI wallet adapters compatibility
+     */
+    async createAndSendTxn(vaultIxs, txParams) {
+        let tx;
+        if ((txParams === null || txParams === void 0 ? void 0 : txParams.noLut) ? txParams.noLut : false) {
+            tx = await this.createTxnNoLut(vaultIxs, txParams);
+            // @ts-ignore
+            tx.sign([this.driftClient.wallet.payer]);
+        }
+        else {
+            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
+     * @param spotMarketIndex spot market index of the insurance fund stake
+     * @returns
+     */
+    async initializeInsuranceFundStake(vault, spotMarketIndex, txParams) {
+        const ixs = await this.getInitializeInsuranceFundStakeIx(vault, spotMarketIndex);
+        return await this.createAndSendTxn([ixs], txParams);
+    }
+    async getInitializeInsuranceFundStakeIx(vault, spotMarketIndex) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const _ifStakeAccountPublicKey = (0, sdk_1.getInsuranceFundStakeAccountPublicKey)(this.driftClient.program.programId, vault, spotMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${spotMarketIndex} not found on driftClient`);
+        }
+        const _ifVaultTokenAccount = (0, addresses_1.getInsuranceFundTokenVaultAddressSync)(this.program.programId, vault, spotMarketIndex);
+        return await this.program.methods
+            .initializeInsuranceFundStake(spotMarketIndex)
+            .accounts({
+            vault: vault,
+            driftSpotMarketMint: spotMarket.mint,
+            driftUserStats: vaultAccount.userStats,
+            driftState: await this.driftClient.getStatePublicKey(),
+        })
+            .instruction();
+    }
+    /**
+     * Adds an amount to an insurance fund stake for the vault.
+     * @param vault vault address to update
+     * @param spotMarketIndex spot market index of the insurance fund stake
+     * @param amount amount to add to the insurance fund stake, in spotMarketIndex precision
+     * @returns
+     */
+    async addToInsuranceFundStake(vault, spotMarketIndex, amount, managerTokenAccount, txParams) {
+        const ixs = await this.getAddToInsuranceFundStakeIx(vault, spotMarketIndex, amount, managerTokenAccount);
+        return await this.createAndSendTxn([ixs], txParams);
+    }
+    async getAddToInsuranceFundStakeIx(vault, spotMarketIndex, amount, managerTokenAccount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        if (!vaultAccount.manager.equals(this.driftClient.wallet.publicKey)) {
+            throw new Error(`Only the manager of the vault can add to the insurance fund stake.`);
+        }
+        const _ifStakeAccountPublicKey = (0, sdk_1.getInsuranceFundStakeAccountPublicKey)(this.driftClient.program.programId, vault, spotMarketIndex);
+        const _ifVaultPublicKey = await (0, sdk_1.getInsuranceFundVaultPublicKey)(this.driftClient.program.programId, spotMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${spotMarketIndex} not found on driftClient`);
+        }
+        if (!managerTokenAccount) {
+            managerTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vaultAccount.manager, true);
+        }
+        const _ifVaultTokenAccount = (0, addresses_1.getInsuranceFundTokenVaultAddressSync)(this.program.programId, vault, spotMarketIndex);
+        return await this.program.methods
+            .addInsuranceFundStake(spotMarketIndex, amount)
+            .accounts({
+            vault: vault,
+            managerTokenAccount,
+            driftUserStats: vaultAccount.userStats,
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftSigner: this.driftClient.getStateAccount().signer,
+        })
+            .instruction();
+    }
+    async requestRemoveInsuranceFundStake(vault, spotMarketIndex, amount, txParams) {
+        const ix = await this.getRequestRemoveInsuranceFundStakeIx(vault, spotMarketIndex, amount);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getRequestRemoveInsuranceFundStakeIx(vault, spotMarketIndex, amount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const _ifStakeAccountPublicKey = (0, sdk_1.getInsuranceFundStakeAccountPublicKey)(this.driftClient.program.programId, vault, spotMarketIndex);
+        const _ifVaultPublicKey = await (0, sdk_1.getInsuranceFundVaultPublicKey)(this.driftClient.program.programId, spotMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${spotMarketIndex} not found on driftClient`);
+        }
+        return await this.program.methods
+            .requestRemoveInsuranceFundStake(spotMarketIndex, amount)
+            .accounts({
+            vault,
+            manager: vaultAccount.manager,
+            driftUserStats: vaultAccount.userStats,
+        })
+            .instruction();
+    }
+    async cancelRequestRemoveInsuranceFundStake(vault, spotMarketIndex, txParams) {
+        const ix = await this.getCancelRequestRemoveInsuranceFundStakeIx(vault, spotMarketIndex);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getCancelRequestRemoveInsuranceFundStakeIx(vault, spotMarketIndex) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const _ifStakeAccountPublicKey = (0, sdk_1.getInsuranceFundStakeAccountPublicKey)(this.driftClient.program.programId, vault, spotMarketIndex);
+        const _ifVaultPublicKey = await (0, sdk_1.getInsuranceFundVaultPublicKey)(this.driftClient.program.programId, spotMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${spotMarketIndex} not found on driftClient`);
+        }
+        return await this.program.methods
+            .cancelRequestRemoveInsuranceFundStake(spotMarketIndex)
+            .accounts({
+            vault: vault,
+            manager: vaultAccount.manager,
+            driftUserStats: vaultAccount.userStats,
+        })
+            .instruction();
+    }
+    async removeInsuranceFundStake(vault, spotMarketIndex, managerTokenAccount, txParams) {
+        const ixs = await this.getRemoveInsuranceFundStakeIx(vault, spotMarketIndex, managerTokenAccount);
+        return await this.createAndSendTxn([ixs], txParams);
+    }
+    async getRemoveInsuranceFundStakeIx(vault, spotMarketIndex, managerTokenAccount) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const _ifStakeAccountPublicKey = (0, sdk_1.getInsuranceFundStakeAccountPublicKey)(this.driftClient.program.programId, vault, spotMarketIndex);
+        const _ifVaultPublicKey = await (0, sdk_1.getInsuranceFundVaultPublicKey)(this.driftClient.program.programId, spotMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(spotMarketIndex);
+        if (!spotMarket) {
+            throw new Error(`Spot market ${spotMarketIndex} not found on driftClient`);
+        }
+        if (!managerTokenAccount) {
+            managerTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vaultAccount.manager, true);
+        }
+        const _ifVaultTokenAccount = (0, addresses_1.getInsuranceFundTokenVaultAddressSync)(this.program.programId, vault, spotMarketIndex);
+        return await this.program.methods
+            .removeInsuranceFundStake(spotMarketIndex)
+            .accounts({
+            vault: vault,
+            managerTokenAccount,
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftUserStats: vaultAccount.userStats,
+            driftSigner: this.driftClient.getStateAccount().signer,
+        })
+            .instruction();
+    }
+    async protocolRequestWithdraw(vault, amount, withdrawUnit, txParams) {
+        const ix = await this.getProtocolRequestWithdrawIx(vault, amount, withdrawUnit);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getProtocolRequestWithdrawIx(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 userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats, false, true, true);
+        const accounts = {
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+        };
+        if (this.cliMode) {
+            return await this.program.methods
+                // @ts-ignore, 0.29.0 anchor issues..
+                .managerRequestWithdraw(amount, withdrawUnit)
+                .accounts(accounts)
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+        }
+        else {
+            const requestWithdrawIx = this.program.instruction.managerRequestWithdraw(
+            // @ts-ignore
+            amount, withdrawUnit, {
+                accounts: {
+                    manager: vaultAccount.manager,
+                    ...accounts,
+                },
+                remainingAccounts,
+            });
+            return requestWithdrawIx;
+        }
+    }
+    async protocolCancelWithdrawRequest(vault, txParams) {
+        const ixs = await this.getProtocolCancelWithdrawRequestIx(vault);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async getProtocolCancelWithdrawRequestIx(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const accounts = {
+            manager: vaultAccount.manager,
+            vault,
+            driftUserStats: userStatsKey,
+            driftUser: vaultAccount.user,
+        };
+        const user = await this.getSubscribedVaultUser(vaultAccount.user);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats, false, true, true);
+        if (this.cliMode) {
+            return [
+                await this.program.methods
+                    .mangerCancelWithdrawRequest()
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .instruction(),
+            ];
+        }
+        else {
+            const cancelRequestWithdrawIx = this.program.instruction.mangerCancelWithdrawRequest({
+                accounts: {
+                    ...accounts,
+                    manager: vaultAccount.manager,
+                },
+                remainingAccounts,
+            });
+            return [cancelRequestWithdrawIx];
+        }
+    }
+    async protocolWithdraw(vault, txParams) {
+        const ixs = await this.getProtocolWithdrawIx(vault);
+        return await this.createAndSendTxn(ixs, txParams);
+    }
+    async getProtocolWithdrawIx(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 userStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, vault);
+        const userStats = (await this.driftClient.program.account.userStats.fetch(userStatsKey));
+        const remainingAccounts = this.getRemainingAccountsForUser([user.getUserAccount()], [], vaultAccount, userStats, false, true, 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: vaultAccount.manager,
+                vaultTokenAccount: vaultAccount.tokenAccount,
+                driftUser: await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, vault),
+                driftProgram: this.driftClient.program.programId,
+                driftUserStats: userStatsKey,
+                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 [ix];
+    }
+    async getPythLazerOracleCrankIxs(oracleFeedsToCrank = [], pythLazerMsgHexGetter) {
+        try {
+            const isPythLazerOracle = (oracleSource) => {
+                const pythLazerStr = JSON.stringify(sdk_1.OracleSource.PYTH_LAZER);
+                const pythLazer1kStr = JSON.stringify(sdk_1.OracleSource.PYTH_LAZER_1K);
+                const pythLazer1mStr = JSON.stringify(sdk_1.OracleSource.PYTH_LAZER_1M);
+                const pythLazerStableCoinStr = JSON.stringify(sdk_1.OracleSource.PYTH_LAZER_STABLE_COIN);
+                const targetOracleSourceStr = JSON.stringify(oracleSource);
+                return (targetOracleSourceStr === pythLazerStr ||
+                    targetOracleSourceStr === pythLazer1kStr ||
+                    targetOracleSourceStr === pythLazer1mStr ||
+                    targetOracleSourceStr === pythLazerStableCoinStr);
+            };
+            const pythLazerOracles = oracleFeedsToCrank.filter((config) => isPythLazerOracle(config.oracleSource));
+            if (pythLazerOracles.length === 0) {
+                return [];
+            }
+            if (!pythLazerMsgHexGetter) {
+                console.error('pythLazerMsgHexGetter is required to crank pyth lazer oracles');
+                return [];
+            }
+            const pythLazerFeedIds = pythLazerOracles
+                .map((config) => config.pythLazerId)
+                .filter(Boolean);
+            const pythLazerMsgHex = await pythLazerMsgHexGetter(pythLazerFeedIds);
+            const oracleUpdateIxs = await this.driftClient.getPostPythLazerOracleUpdateIxs(pythLazerFeedIds, pythLazerMsgHex, undefined, 3);
+            return oracleUpdateIxs;
+        }
+        catch (err) {
+            console.error('Error cranking pyth lazer oracles', err);
+            return [];
+        }
+    }
+    async getOracleFeedsToCrankIxs(oracleFeedsToCrank) {
+        if (!(oracleFeedsToCrank === null || oracleFeedsToCrank === void 0 ? void 0 : oracleFeedsToCrank.feedsToCrank)) {
+            return [];
+        }
+        return await this.getPythLazerOracleCrankIxs(oracleFeedsToCrank.feedsToCrank, oracleFeedsToCrank.pythLazerMsgHexGetter);
+    }
+    async updateVaultProtocol(vault, params, txParams) {
+        const ix = await this.getUpdateVaultProtocolIx(vault, params);
+        return await this.createAndSendTxn([ix], txParams);
+    }
+    async getUpdateVaultProtocolIx(vault, params) {
+        return this.program.methods
+            .updateVaultProtocol(params)
+            .accounts({
+            vault,
+            vaultProtocol: this.getVaultProtocolAddress(vault),
+        })
+            .instruction();
+    }
+    async adminInitFeeUpdate(vault, uiTxParams) {
+        const ix = await this.getAdminInitFeeUpdateIx(vault);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getAdminInitFeeUpdateIx(vault) {
+        const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vault);
+        return this.program.instruction.adminInitFeeUpdate({
+            accounts: {
+                vault,
+                admin: this.driftClient.wallet.publicKey,
+                feeUpdate,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+        });
+    }
+    async adminDeleteFeeUpdate(vault, uiTxParams) {
+        const ix = await this.getAdminDeleteFeeUpdateIx(vault);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getAdminDeleteFeeUpdateIx(vault) {
+        const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vault);
+        return this.program.instruction.adminDeleteFeeUpdate({
+            accounts: {
+                vault,
+                admin: this.driftClient.wallet.publicKey,
+                feeUpdate,
+            },
+        });
+    }
+    async adminUpdateVaultClass(vault, newVaultClass, uiTxParams) {
+        const ix = await this.getAdminUpdateVaultClassIx(vault, newVaultClass);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getAdminUpdateVaultClassIx(vault, newVaultClass) {
+        return this.program.methods
+            .adminUpdateVaultClass(newVaultClass)
+            .accounts({
+            vault,
+            admin: this.driftClient.wallet.publicKey,
+        })
+            .instruction();
+    }
+    async managerUpdateFees(vault, params, uiTxParams) {
+        const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vault);
+        const ixs = [];
+        if (!(await this.checkIfAccountExists(feeUpdate))) {
+            throw new Error('Fee update account does not exist, it must be created by an admin first');
+        }
+        ixs.push(await this.getManagerUpdateFeesIx(vault, params));
+        return await this.createAndSendTxn(ixs, uiTxParams);
+    }
+    async getManagerUpdateFeesIx(vault, params) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vault);
+        return this.program.instruction.managerUpdateFees(params, {
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+                feeUpdate,
+            },
+        });
+    }
+    async managerCancelFeeUpdate(vault, uiTxParams) {
+        const ix = await this.getManagerCancelFeeUpdateIx(vault);
+        return await this.createAndSendTxn([ix], uiTxParams);
+    }
+    async getManagerCancelFeeUpdateIx(vault) {
+        const vaultAccount = await this.program.account.vault.fetch(vault);
+        const feeUpdate = (0, addresses_1.getFeeUpdateAddressSync)(this.program.programId, vault);
+        return this.program.instruction.managerCancelFeeUpdate({
+            accounts: {
+                vault,
+                manager: vaultAccount.manager,
+                feeUpdate,
+            },
+        });
+    }
+    /**
+     * Calculate the vault share price (base value per share)
+     * @param params vault address or vault account, and precision exponent
+     * @returns BigNum representing the base value per share
+     */
+    async calcVaultSharePrice(params) {
+        let spotPrecisionExp = sdk_1.QUOTE_PRECISION_EXP;
+        try {
+            let vaultAccount;
+            if (params.address !== undefined) {
+                vaultAccount = await this.program.account.vault.fetch(params.address);
+            }
+            else if (params.vault !== undefined) {
+                vaultAccount = params.vault;
+            }
+            else {
+                throw new Error('Must supply address or vault');
+            }
+            const spotMarket = this.driftClient.getSpotMarketAccount(vaultAccount.spotMarketIndex);
+            spotPrecisionExp = new sdk_1.BN(spotMarket.decimals);
+            const totalAccountValue = await this.calculateVaultEquityInDepositAsset({
+                vault: vaultAccount,
+                factorUnrealizedPNL: true,
+            });
+            const vaultTotalShares = vaultAccount.totalShares.toString();
+            const totalAccountValueStr = totalAccountValue.toString();
+            return vaultTotalShares === '0'
+                ? sdk_1.BigNum.from(0, spotPrecisionExp)
+                : new sdk_1.BigNum(totalAccountValueStr, spotPrecisionExp)
+                    .shift(constants_1.VAULT_SHARES_PRECISION_EXP)
+                    .div(new sdk_1.BigNum(vaultTotalShares, constants_1.VAULT_SHARES_PRECISION_EXP));
+        }
+        catch (err) {
+            console.error('VaultClient calcVaultSharePrice error:', err);
+            return sdk_1.BigNum.from(0, spotPrecisionExp);
+        }
+    }
+}
+exports.VaultClient = VaultClient;