@drift-labs/vaults-sdk 0.1.531 → 0.1.532

package/lib/types/drift_vaults.js

@@ -315,6 +315,177 @@ exports.IDL = {
             ],
             args: [],
         },
+        {
+            name: 'initializeTokenizedVaultDepositor',
+            accounts: [
+                {
+                    name: 'vault',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'vaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'mintAccount',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'metadataAccount',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'tokenProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenMetadataProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'rent',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'params',
+                    type: {
+                        defined: 'InitializeTokenizedVaultDepositorParams',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'tokenizeShares',
+            accounts: [
+                {
+                    name: 'vault',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'vaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'tokenizedVaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'mint',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'userTokenAccount',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'driftUser',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'amount',
+                    type: 'u64',
+                },
+                {
+                    name: 'unit',
+                    type: {
+                        defined: 'WithdrawUnit',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'redeemTokens',
+            accounts: [
+                {
+                    name: 'vault',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'vaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'tokenizedVaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'mint',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'userTokenAccount',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'vaultTokenAccount',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'driftUser',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'tokensToBurn',
+                    type: 'u64',
+                },
+            ],
+        },
         {
             name: 'deposit',
             accounts: [
@@ -838,6 +1009,48 @@ exports.IDL = {
             ],
             args: [],
         },
+        {
+            name: 'applyRebase',
+            accounts: [
+                {
+                    name: 'vault',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'vaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'driftUser',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [],
+        },
+        {
+            name: 'applyRebaseTokenizedDepositor',
+            accounts: [
+                {
+                    name: 'vault',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'tokenizedVaultDepositor',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'driftUser',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [],
+        },
         {
             name: 'forceWithdraw',
             accounts: [
@@ -965,57 +1178,6 @@ exports.IDL = {
                 },
             ],
         },
-        {
-            name: 'initializeCompetitor',
-            accounts: [
-                {
-                    name: 'vault',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'manager',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'payer',
-                    isMut: true,
-                    isSigner: true,
-                },
-                {
-                    name: 'rent',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'competitor',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'driftCompetitions',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'driftUserStats',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'driftCompetitionsProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [],
-        },
         {
             name: 'protocolRequestWithdraw',
             accounts: [
@@ -1167,6 +1329,105 @@ exports.IDL = {
         },
     ],
     accounts: [
+        {
+            name: 'tokenizedVaultDepositor',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'vault',
+                        docs: ['The vault deposited into'],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'pubkey',
+                        docs: [
+                            "The vault depositor account's pubkey. It is a pda of vault",
+                        ],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'mint',
+                        docs: [
+                            'The token mint for tokenized shares owned by this VaultDepositor',
+                        ],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'vaultShares',
+                        docs: [
+                            "share of vault owned by this depositor. vault_shares / vault.total_shares is depositor's ownership of vault_equity",
+                        ],
+                        type: 'u128',
+                    },
+                    {
+                        name: 'lastVaultShares',
+                        docs: [
+                            'stores the vault_shares from the most recent liquidity event (redeem or issuance) before a spl token',
+                            'CPI is done, used to track invariants',
+                        ],
+                        type: 'u128',
+                    },
+                    {
+                        name: 'lastValidTs',
+                        docs: ['creation ts of vault depositor'],
+                        type: 'i64',
+                    },
+                    {
+                        name: 'netDeposits',
+                        docs: ['lifetime net deposits of vault depositor for the vault'],
+                        type: 'i64',
+                    },
+                    {
+                        name: 'totalDeposits',
+                        docs: ['lifetime total deposits'],
+                        type: 'u64',
+                    },
+                    {
+                        name: 'totalWithdraws',
+                        docs: ['lifetime total withdraws'],
+                        type: 'u64',
+                    },
+                    {
+                        name: 'cumulativeProfitShareAmount',
+                        docs: [
+                            'the token amount of gains the vault depositor has paid performance fees on',
+                        ],
+                        type: 'i64',
+                    },
+                    {
+                        name: 'profitShareFeePaid',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'vaultSharesBase',
+                        docs: [
+                            'The exponent for vault_shares decimal places at the time the tokenized vault depositor was initialized.',
+                            'If the vault undergoes a rebase, this TokenizedVaultDepositor can no longer issue new tokens, only redeem',
+                            'is possible.',
+                        ],
+                        type: 'u32',
+                    },
+                    {
+                        name: 'bump',
+                        docs: ['The bump for the vault pda'],
+                        type: 'u8',
+                    },
+                    {
+                        name: 'padding1',
+                        type: {
+                            array: ['u8', 3],
+                        },
+                    },
+                    {
+                        name: 'padding',
+                        type: {
+                            array: ['u64', 10],
+                        },
+                    },
+                ],
+            },
+        },
         {
             name: 'vaultDepositor',
             type: {
@@ -1557,6 +1818,30 @@ exports.IDL = {
         },
     ],
     types: [
+        {
+            name: 'InitializeTokenizedVaultDepositorParams',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'tokenName',
+                        type: 'string',
+                    },
+                    {
+                        name: 'tokenSymbol',
+                        type: 'string',
+                    },
+                    {
+                        name: 'tokenUri',
+                        type: 'string',
+                    },
+                    {
+                        name: 'decimals',
+                        type: 'u8',
+                    },
+                ],
+            },
+        },
         {
             name: 'VaultWithProtocolParams',
             type: {
@@ -1790,6 +2075,12 @@ exports.IDL = {
                     {
                         name: 'FeePayment',
                     },
+                    {
+                        name: 'TokenizeShares',
+                    },
+                    {
+                        name: 'RedeemTokens',
+                    },
                 ],
             },
         },
@@ -2031,6 +2322,61 @@ exports.IDL = {
                 },
             ],
         },
+        {
+            name: 'ShareTransferRecord',
+            fields: [
+                {
+                    name: 'ts',
+                    type: 'i64',
+                    index: false,
+                },
+                {
+                    name: 'vault',
+                    type: 'publicKey',
+                    index: false,
+                },
+                {
+                    name: 'fromVaultDepositor',
+                    type: 'publicKey',
+                    index: false,
+                },
+                {
+                    name: 'toVaultDepositor',
+                    type: 'publicKey',
+                    index: false,
+                },
+                {
+                    name: 'shares',
+                    type: 'u128',
+                    index: false,
+                },
+                {
+                    name: 'value',
+                    type: 'u64',
+                    index: false,
+                },
+                {
+                    name: 'fromDepositorSharesBefore',
+                    type: 'u128',
+                    index: false,
+                },
+                {
+                    name: 'fromDepositorSharesAfter',
+                    type: 'u128',
+                    index: false,
+                },
+                {
+                    name: 'toDepositorSharesBefore',
+                    type: 'u128',
+                    index: false,
+                },
+                {
+                    name: 'toDepositorSharesAfter',
+                    type: 'u128',
+                    index: false,
+                },
+            ],
+        },
     ],
     errors: [
         {
@@ -2148,5 +2494,10 @@ exports.IDL = {
             name: 'VaultProtocolMissing',
             msg: 'VaultProtocolMissing',
         },
+        {
+            code: 6023,
+            name: 'InvalidTokenization',
+            msg: 'InvalidTokenization',
+        },
     ],
 };

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.
@@ -253,13 +280,6 @@ export declare class VaultClient {
      * @returns
      */
     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
-     * @returns
-     */
-    initializeCompetitor(vault: PublicKey, competitionsClient: CompetitionsClient, competitionName: string): Promise<TransactionSignature>;
     protocolRequestWithdraw(vault: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
     protocolCancelWithdrawRequest(vault: PublicKey): Promise<TransactionSignature>;
     protocolWithdraw(vault: PublicKey): Promise<TransactionSignature>;