@drift-labs/vaults-sdk 0.1.531 → 0.1.533

package/lib/utils.d.ts

@@ -1,7 +1,8 @@
 import { DriftClient, IWallet } from '@drift-labs/sdk';
-import { Connection } from '@solana/web3.js';
+import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { DriftVaults } from './types/drift_vaults';
 import { VaultClient } from './vaultClient';
 import * as anchor from '@coral-xyz/anchor';
 export declare const getDriftVaultProgram: (connection: Connection, wallet: IWallet) => anchor.Program<DriftVaults>;
 export declare const getVaultClient: (connection: Connection, wallet: IWallet, driftClient: DriftClient) => VaultClient;
+export declare const getOrCreateATAInstruction: (tokenMint: PublicKey, owner: PublicKey, connection: Connection, allowOwnerOffCurve?: boolean, payer?: PublicKey) => Promise<[PublicKey, TransactionInstruction?]>;

package/lib/utils.js

@@ -23,12 +23,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVaultClient = exports.getDriftVaultProgram = void 0;
+exports.getOrCreateATAInstruction = exports.getVaultClient = exports.getDriftVaultProgram = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const drift_vaults_1 = require("./types/drift_vaults");
 const vaultClient_1 = require("./vaultClient");
 const anchor = __importStar(require("@coral-xyz/anchor"));
 const types_1 = require("./types/types");
+const spl_token_1 = require("@solana/spl-token");
 const getDriftVaultProgram = (connection, wallet) => {
     const provider = new anchor_1.AnchorProvider(connection, wallet, {});
     anchor.setProvider(provider);
@@ -45,3 +46,21 @@ const getVaultClient = (connection, wallet, driftClient) => {
     return vaultClient;
 };
 exports.getVaultClient = getVaultClient;
+const getOrCreateATAInstruction = async (tokenMint, owner, connection, allowOwnerOffCurve = true, payer = owner) => {
+    let toAccount;
+    try {
+        toAccount = await (0, spl_token_1.getAssociatedTokenAddress)(tokenMint, owner, allowOwnerOffCurve);
+        const account = await connection.getAccountInfo(toAccount);
+        if (!account) {
+            const ix = (0, spl_token_1.createAssociatedTokenAccountInstruction)(payer, toAccount, owner, tokenMint);
+            return [toAccount, ix];
+        }
+        return [toAccount, undefined];
+    }
+    catch (e) {
+        /* handle error */
+        console.error('Error::getOrCreateATAInstruction', e);
+        throw e;
+    }
+};
+exports.getOrCreateATAInstruction = getOrCreateATAInstruction;

package/lib/vaultClient.d.ts

@@ -1,10 +1,10 @@
 import { BN, DriftClient, UserMap } from '@drift-labs/sdk';
 import { Program, ProgramAccount } from '@coral-xyz/anchor';
 import { DriftVaults } from './types/drift_vaults';
-import { CompetitionsClient } from '@drift-labs/competitions-sdk';
 import { AddressLookupTableAccount, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
 import { Vault, VaultDepositor, VaultProtocol, VaultProtocolParams, WithdrawUnit } from './types/types';
 import { UserMapConfig } from '@drift-labs/sdk';
+import { Metaplex } from '@metaplex-foundation/js';
 export type TxParams = {
     cuLimit?: number;
     cuPriceMicroLamports?: number;
@@ -13,15 +13,17 @@ export type TxParams = {
 };
 export declare class VaultClient {
     driftClient: DriftClient;
+    metaplex?: Metaplex;
     program: Program<DriftVaults>;
     cliMode: boolean;
     /**
      * Cache map of drift user accounts of vaults.
      */
     readonly vaultUsers: UserMap;
-    constructor({ driftClient, program, cliMode, userMapConfig, }: {
+    constructor({ driftClient, program, metaplex, cliMode, userMapConfig, }: {
         driftClient: DriftClient;
         program: Program<DriftVaults>;
+        metaplex?: Metaplex;
         cliMode?: boolean;
         userMapConfig?: UserMapConfig;
     });
@@ -136,6 +138,10 @@ export declare class VaultClient {
         permissioned: boolean | null;
     }): Promise<TransactionSignature>;
     getApplyProfitShareIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
+    getApplyRebaseTokenizedDepositorIx(vault: PublicKey, tokenizedVaultDepositor: PublicKey): Promise<TransactionInstruction>;
+    applyRebase(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    getApplyRebaseIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
+    applyRebaseTokenizedDepositor(vault: PublicKey, tokenizedVaultDepositor: PublicKey): Promise<TransactionSignature>;
     private createInitVaultDepositorIx;
     /**
      * Initializes the vault depositor account. This account is used to deposit funds into a vault.
@@ -144,10 +150,30 @@ export declare class VaultClient {
      * @returns
      */
     initializeVaultDepositor(vault: PublicKey, authority?: PublicKey): Promise<TransactionSignature>;
+    initializeTokenizedVaultDepositor(params: {
+        vault: PublicKey;
+        tokenName: string;
+        tokenSymbol: string;
+        tokenUri: string;
+        decimals?: number;
+        sharesBase?: number;
+    }): Promise<TransactionSignature>;
+    createTokenizeSharesIx(vaultDepositor: PublicKey, amount: BN, unit: WithdrawUnit, mint?: PublicKey): Promise<TransactionInstruction[]>;
+    tokenizeShares(vaultDepositor: PublicKey, amount: BN, unit: WithdrawUnit, mint?: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    createRedeemTokensIx(vaultDepositor: PublicKey, tokensToBurn: BN, sharesBase?: number): Promise<TransactionInstruction>;
+    /**
+     * 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
+     */
+    redeemTokens(vaultDepositor: PublicKey, tokensToBurn: BN, sharesBase?: number, txParams?: TxParams): Promise<TransactionSignature>;
     prepDepositTx(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
         authority: PublicKey;
         vault: PublicKey;
-    }): Promise<{
+    }, userTokenAccount?: PublicKey): Promise<{
         vaultAccount: {
             name: number[];
             pubkey: PublicKey;
@@ -228,10 +254,11 @@ export declare class VaultClient {
     deposit(vaultDepositor: PublicKey, amount: BN, initVaultDepositor?: {
         authority: PublicKey;
         vault: PublicKey;
-    }, txParams?: TxParams): Promise<TransactionSignature>;
+    }, txParams?: TxParams, userTokenAccount?: PublicKey): Promise<TransactionSignature>;
     requestWithdraw(vaultDepositor: PublicKey, amount: BN, withdrawUnit: WithdrawUnit, txParams?: TxParams): Promise<TransactionSignature>;
     withdraw(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     forceWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    getForceWithdrawIx(vaultDepositor: PublicKey): Promise<TransactionInstruction[]>;
     cancelRequestWithdraw(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     /**
      * Liquidates (become delegate for) a vault.
@@ -254,12 +281,16 @@ export declare class VaultClient {
      */
     initializeInsuranceFundStake(vault: PublicKey, spotMarketIndex: number): Promise<TransactionSignature>;
     /**
-     * Initializes a DriftCompetitions Competitor account for the vault.
-     * @param vault vault address to initialize Competitor for
-     * @param competitionName name of the competition to initialize for
+     * 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
      */
-    initializeCompetitor(vault: PublicKey, competitionsClient: CompetitionsClient, competitionName: string): Promise<TransactionSignature>;
+    addToInsuranceFundStake(vault: PublicKey, spotMarketIndex: number, amount: BN, managerTokenAccount?: PublicKey): Promise<TransactionSignature>;
+    requestRemoveInsuranceFundStake(vault: PublicKey, spotMarketIndex: number, amount: BN): Promise<TransactionSignature>;
+    cancelRequestRemoveInsuranceFundStake(vault: PublicKey, spotMarketIndex: number): Promise<TransactionSignature>;
+    removeInsuranceFundStake(vault: PublicKey, spotMarketIndex: number, managerTokenAccount?: PublicKey): Promise<TransactionSignature>;
     protocolRequestWithdraw(vault: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
     protocolCancelWithdrawRequest(vault: PublicKey): Promise<TransactionSignature>;
     protocolWithdraw(vault: PublicKey): Promise<TransactionSignature>;

package/lib/vaultClient.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultClient = void 0;
 const sdk_1 = require("@drift-labs/sdk");
 const anchor_1 = require("@coral-xyz/anchor");
-const competitions_sdk_1 = require("@drift-labs/competitions-sdk");
 const addresses_1 = require("./addresses");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
 const math_1 = require("./math");
+const utils_1 = require("./utils");
 class VaultClient {
-    constructor({ driftClient, program, cliMode, userMapConfig, }) {
+    constructor({ driftClient, program, metaplex, cliMode, userMapConfig, }) {
         this.driftClient = driftClient;
+        this.metaplex = metaplex;
         this.program = program;
         this.cliMode = !!cliMode;
         if (!userMapConfig) {
@@ -574,6 +575,68 @@ class VaultClient {
             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 remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        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 remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        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) {
         const vaultDepositor = (0, addresses_1.getVaultDepositorAddressSync)(this.program.programId, vault, authority || this.driftClient.wallet.publicKey);
         const accounts = {
@@ -605,9 +668,14 @@ class VaultClient {
             authority: authority || this.driftClient.wallet.publicKey,
         };
         if (this.cliMode) {
-            return await this.program.methods
+            return this.program.methods
                 .initializeVaultDepositor()
-                .accounts(accounts)
+                .accounts({
+                ...accounts,
+                payer: authority || this.driftClient.wallet.publicKey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            })
                 .rpc();
         }
         else {
@@ -615,7 +683,156 @@ class VaultClient {
             return await this.createAndSendTxn([initIx]);
         }
     }
-    async prepDepositTx(vaultDepositor, amount, initVaultDepositor) {
+    async initializeTokenizedVaultDepositor(params) {
+        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 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: this.driftClient.wallet.publicKey,
+        };
+        const vaultTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mintAddress, params.vault, true);
+        const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.driftClient.wallet.publicKey, vaultTokenAta, params.vault, mintAddress);
+        if (!this.cliMode) {
+            throw new Error('CLI mode is not supported for initializeTokenizedVaultDepositor');
+        }
+        return await this.program.methods
+            .initializeTokenizedVaultDepositor({
+            ...params,
+            decimals: (_a = params.decimals) !== null && _a !== void 0 ? _a : spotMarketDecimals,
+        })
+            .preInstructions([
+            web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 50000,
+            }),
+        ])
+            .postInstructions([createAtaIx])
+            .accounts(accounts)
+            .rpc();
+    }
+    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 remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        ixs.push(await this.program.methods
+            // anchor idl bug: https://github.com/coral-xyz/anchor/issues/2914
+            // @ts-ignore
+            .tokenizeShares(amount, unit)
+            .accounts({
+            authority: this.driftClient.wallet.publicKey,
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            tokenizedVaultDepositor: (0, addresses_1.getTokenizedVaultAddressSync)(this.program.programId, vaultDepositorAccount.vault, vaultAccount.sharesBase),
+            mint,
+            userTokenAccount: userAta,
+            driftUser: vaultAccount.user,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction());
+        return ixs;
+    }
+    async tokenizeShares(vaultDepositor, amount, unit, mint, txParams) {
+        const ixs = await this.createTokenizeSharesIx(vaultDepositor, amount, unit, mint);
+        if (this.cliMode) {
+            try {
+                const tx = new web3_js_1.Transaction().add(...ixs);
+                const txSig = await this.driftClient.txSender.send(tx, undefined, undefined, false);
+                return txSig.txSig;
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+        }
+        else {
+            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 remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [user.getUserAccount()],
+            writableSpotMarketIndexes: [vaultAccount.spotMarketIndex],
+        });
+        return await this.program.methods
+            .redeemTokens(tokensToBurn)
+            .accounts({
+            authority: this.driftClient.wallet.publicKey,
+            vault: vaultDepositorAccount.vault,
+            vaultDepositor,
+            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,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .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);
+        if (this.cliMode) {
+            try {
+                const tx = new web3_js_1.Transaction().add(ix);
+                const txSig = await this.driftClient.txSender.send(tx, undefined, undefined, false);
+                return txSig.txSig;
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+        }
+        else {
+            return await this.createAndSendTxn([ix], txParams);
+        }
+    }
+    async prepDepositTx(vaultDepositor, amount, initVaultDepositor, userTokenAccount) {
         let vaultPubKey;
         if (initVaultDepositor) {
             vaultPubKey = initVaultDepositor.vault;
@@ -652,7 +869,7 @@ class VaultClient {
             driftUser: vaultAccount.user,
             driftState: driftStateKey,
             driftSpotMarketVault: spotMarket.vault,
-            userTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true),
+            userTokenAccount: userTokenAccount !== null && userTokenAccount !== void 0 ? userTokenAccount : (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, this.driftClient.wallet.publicKey, true),
             driftProgram: this.driftClient.program.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
@@ -696,13 +913,13 @@ class VaultClient {
      * @param txParams
      * @returns
      */
-    async deposit(vaultDepositor, amount, initVaultDepositor, txParams) {
+    async deposit(vaultDepositor, amount, initVaultDepositor, txParams, userTokenAccount) {
         if (this.cliMode) {
-            const { vaultAccount, accounts, remainingAccounts } = await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor);
+            const { vaultAccount, accounts, remainingAccounts } = await this.prepDepositTx(vaultDepositor, amount, initVaultDepositor, userTokenAccount);
             if (initVaultDepositor) {
                 await this.initializeVaultDepositor(vaultAccount.pubkey, initVaultDepositor.authority);
             }
-            return await this.program.methods
+            return this.program.methods
                 .deposit(amount)
                 .accounts(accounts)
                 .remainingAccounts(remainingAccounts)
@@ -838,6 +1055,10 @@ class VaultClient {
         }
     }
     async forceWithdraw(vaultDepositor) {
+        const ix = await this.getForceWithdrawIx(vaultDepositor);
+        return await this.createAndSendTxn(ix);
+    }
+    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);
@@ -859,6 +1080,10 @@ class VaultClient {
         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: this.driftClient.wallet.publicKey,
             vault: vaultDepositorAccount.vault,
@@ -869,34 +1094,20 @@ class VaultClient {
             driftState: driftStateKey,
             driftSpotMarketVault: spotMarket.vault,
             driftSigner: this.driftClient.getStateAccount().signer,
-            userTokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(spotMarket.mint, vaultDepositorAccount.authority, true),
+            userTokenAccount,
             driftProgram: this.driftClient.program.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
-        if (this.cliMode) {
-            return await this.program.methods
-                .forceWithdraw()
-                .preInstructions([
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 500000,
-                }),
-                web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: 50000,
-                }),
-            ])
-                .accounts(accounts)
-                .remainingAccounts(remainingAccounts)
-                .rpc();
-        }
-        else {
-            const forceWithdrawIx = this.program.instruction.forceWithdraw({
-                accounts: {
-                    ...accounts,
-                },
-                remainingAccounts,
-            });
-            return await this.createAndSendTxn([forceWithdrawIx]);
+        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 vaultDepositorAccount = await this.program.account.vaultDepositor.fetch(vaultDepositor);
@@ -1051,11 +1262,14 @@ class VaultClient {
         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,
             driftSpotMarket: spotMarket.pubkey,
+            driftSpotMarketMint: spotMarket.mint,
+            vaultTokenAccount: ifVaultTokenAccount,
             insuranceFundStake: ifStakeAccountPublicKey,
             driftUserStats: vaultAccount.userStats,
             driftState: await this.driftClient.getStatePublicKey(),
@@ -1064,24 +1278,113 @@ class VaultClient {
             .rpc();
     }
     /**
-     * Initializes a DriftCompetitions Competitor account for the vault.
-     * @param vault vault address to initialize Competitor for
-     * @param competitionName name of the competition to initialize for
+     * 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 initializeCompetitor(vault, competitionsClient, competitionName) {
+    async addToInsuranceFundStake(vault, spotMarketIndex, amount, managerTokenAccount) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
-        const encodedName = (0, sdk_1.encodeName)(competitionName);
-        const competitionAddress = (0, competitions_sdk_1.getCompetitionAddressSync)(competitionsClient.program.programId, encodedName);
-        const competitorAddress = (0, competitions_sdk_1.getCompetitorAddressSync)(competitionsClient.program.programId, competitionAddress, 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, this.driftClient.wallet.publicKey);
+        }
+        const ifVaultTokenAccount = (0, addresses_1.getInsuranceFundTokenVaultAddressSync)(this.program.programId, vault, spotMarketIndex);
         return await this.program.methods
-            .initializeCompetitor()
+            .addInsuranceFundStake(spotMarketIndex, amount)
             .accounts({
             vault: vault,
-            competitor: competitorAddress,
-            driftCompetitions: competitionAddress,
+            driftSpotMarket: spotMarket.pubkey,
+            driftSpotMarketVault: spotMarket.vault,
+            insuranceFundStake: ifStakeAccountPublicKey,
+            insuranceFundVault: ifVaultPublicKey,
+            managerTokenAccount,
+            vaultIfTokenAccount: ifVaultTokenAccount,
             driftUserStats: vaultAccount.userStats,
-            driftCompetitionsProgram: competitionsClient.program.programId,
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftProgram: this.driftClient.program.programId,
+            driftSigner: this.driftClient.getStateAccount().signer,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .rpc();
+    }
+    async requestRemoveInsuranceFundStake(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: this.driftClient.wallet.publicKey,
+            driftSpotMarket: spotMarket.pubkey,
+            insuranceFundStake: ifStakeAccountPublicKey,
+            insuranceFundVault: ifVaultPublicKey,
+            driftUserStats: vaultAccount.userStats,
+            driftProgram: this.driftClient.program.programId,
+        })
+            .rpc();
+    }
+    async cancelRequestRemoveInsuranceFundStake(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: this.driftClient.wallet.publicKey,
+            driftSpotMarket: spotMarket.pubkey,
+            insuranceFundStake: ifStakeAccountPublicKey,
+            insuranceFundVault: ifVaultPublicKey,
+            driftUserStats: vaultAccount.userStats,
+            driftProgram: this.driftClient.program.programId,
+        })
+            .rpc();
+    }
+    async removeInsuranceFundStake(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, this.driftClient.wallet.publicKey);
+        }
+        const ifVaultTokenAccount = (0, addresses_1.getInsuranceFundTokenVaultAddressSync)(this.program.programId, vault, spotMarketIndex);
+        return await this.program.methods
+            .removeInsuranceFundStake(spotMarketIndex)
+            .accounts({
+            vault: vault,
+            driftSpotMarket: spotMarket.pubkey,
+            insuranceFundStake: ifStakeAccountPublicKey,
+            insuranceFundVault: ifVaultPublicKey,
+            managerTokenAccount,
+            vaultIfTokenAccount: ifVaultTokenAccount,
+            driftState: await this.driftClient.getStatePublicKey(),
+            driftUserStats: vaultAccount.userStats,
+            driftSigner: this.driftClient.getStateAccount().signer,
+            driftProgram: this.driftClient.program.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         })
             .rpc();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/vaults-sdk",
-  "version": "0.1.531",
+  "version": "0.1.533",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "directories": {
@@ -8,11 +8,11 @@
   },
   "dependencies": {
     "@coral-xyz/anchor": "0.28.0",
-    "@drift-labs/competitions-sdk": "0.2.519",
     "@drift-labs/sdk": "2.98.0-beta.9",
     "@ledgerhq/hw-app-solana": "^7.1.1",
     "@ledgerhq/hw-transport": "^6.30.1",
     "@ledgerhq/hw-transport-node-hid": "^6.28.1",
+    "@metaplex-foundation/js": "^0.20.1",
     "@solana/wallet-adapter-ledger": "^0.9.25",
     "@solana/web3.js": "1.92.3",
     "commander": "^11.0.0",