@drift-labs/vaults-sdk 0.1.531 → 0.1.532

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);
@@ -1063,28 +1274,6 @@ 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
-     * @returns
-     */
-    async initializeCompetitor(vault, competitionsClient, competitionName) {
-        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);
-        return await this.program.methods
-            .initializeCompetitor()
-            .accounts({
-            vault: vault,
-            competitor: competitorAddress,
-            driftCompetitions: competitionAddress,
-            driftUserStats: vaultAccount.userStats,
-            driftCompetitionsProgram: competitionsClient.program.programId,
-        })
-            .rpc();
-    }
     async protocolRequestWithdraw(vault, amount, withdrawUnit) {
         // @ts-ignore
         const vaultAccount = (await this.program.account.vault.fetch(vault));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/vaults-sdk",
-  "version": "0.1.531",
+  "version": "0.1.532",
   "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",

package/src/addresses.ts

@@ -54,3 +54,33 @@ export function getVaultProtocolAddressSync(
 		programId
 	)[0];
 }
+
+export function getTokenizedVaultAddressSync(
+	programId: PublicKey,
+	vault: PublicKey,
+	sharesBase: number
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('tokenized_vault_depositor')),
+			vault.toBuffer(),
+			Buffer.from(anchor.utils.bytes.utf8.encode(sharesBase.toString())),
+		],
+		programId
+	)[0];
+}
+
+export function getTokenizedVaultMintAddressSync(
+	programId: PublicKey,
+	vault: PublicKey,
+	sharesBase: number
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('mint')),
+			vault.toBuffer(),
+			Buffer.from(anchor.utils.bytes.utf8.encode(sharesBase.toString())),
+		],
+		programId
+	)[0];
+}