@drift-labs/vaults-sdk 0.1.211 → 0.1.212

package/cli/cli.ts

@@ -74,7 +74,8 @@ program
     .command("manager-request-withdraw")
     .description("Make a withdraw request from your vault")
     .addOption(new Option("--vault-address <address>", "Address of the vault to withdraw from").makeOptionMandatory(true))
-    .addOption(new Option("--shares <shares>", "Amount of shares to withdraw (raw precision, as expected by contract)").makeOptionMandatory(true))
+    .addOption(new Option("--shares <shares>", "Amount of shares to withdraw (raw precision, as expected by contract)").makeOptionMandatory(false))
+    .addOption(new Option("--amount <amount>", "Amount of spot asset to withdraw (human format, 5 for 5 USDC)").makeOptionMandatory(false))
     .action((opts) => managerRequestWithdraw(program, opts));
 program
     .command("manager-update-vault")
@@ -113,6 +114,7 @@ program
     .command("apply-profit-share-all")
     .description("Turn the profit share crank for all depositors")
     .addOption(new Option("--vault-address <address>", "Address of the vault to view").makeOptionMandatory(true))
+    .addOption(new Option("--threshold <amount>", "Minimum threshold (in spot tokens) before profit share is applied").default("1000", "default is 1000"))
     .action((opts) => applyProfitShare(program, opts));
 program
     .command("init-vault-depositor")
@@ -142,6 +144,8 @@ program
     .command("force-withdraw")
     .description("Forces the vault to send out a withdraw after the redeem period has passed")
     .addOption(new Option("--vault-depositor-address <vaultDepositorAddress>", "VaultDepositor address").makeOptionMandatory(false))
+    .addOption(new Option("--vault-depositor-authority <vaultDepositorAuthority>", "Authority address of VaultDepositor, must also provide --vault-address").makeOptionMandatory(false))
+    .addOption(new Option("--vault-address <vaultAddress>", "Address of vault, must required if only --vault-deposit-authority is provided").makeOptionMandatory(false))
     .action((opts) => forceWithdraw(program, opts));
 program
     .command("decode-logs")
@@ -152,6 +156,8 @@ program
     .command("check-invariants")
     .description("Perform sanity checks on vault/depositor invariants")
     .addOption(new Option("--vault-address <address>", "Vault address").makeOptionMandatory(true))
+    .addOption(new Option("--csv", "Output to csv"))
+
     .action((opts) => vaultInvariantChecks(program, opts));
 
 program.parseAsync().then(() => {

package/cli/commands/applyProfitShare.ts

@@ -4,6 +4,9 @@ import {
     Command
 } from "commander";
 import { getCommandContext } from "../utils";
+import { VaultDepositor, calculateApplyProfitShare } from "../../src";
+import { BN, TEN, ZERO, numberToSafeBN } from "@drift-labs/sdk";
+import { ProgramAccount } from "@coral-xyz/anchor";
 
 export const applyProfitShare = async (program: Command, cmdOpts: OptionValues) => {
 
@@ -16,18 +19,42 @@ export const applyProfitShare = async (program: Command, cmdOpts: OptionValues)
     }
 
     const {
-        driftVault
+        driftVault,
+        driftClient,
     } = await getCommandContext(program, true);
 
-    const vdToRealizeProfit = await driftVault.getAllVaultDepositorsWithNoWithdrawRequest(vaultAddress);
-    console.log(`Applying profit share for ${vdToRealizeProfit.length} depositors...`);
+    const vault = await driftVault.getVault(vaultAddress);
+    const vdWithNoWithdrawRequests = await driftVault.getAllVaultDepositorsWithNoWithdrawRequest(vaultAddress);
+    const vaultEquity = await driftVault.calculateVaultEquity({ vault });
 
-    const chunkSize = 6;
+    const spotMarket = driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+    if (!spotMarket) {
+        throw new Error(`Spot market account ${vault.spotMarketIndex} has not been loaded`);
+    }
+    const spotMarketPrecision = TEN.pow(new BN(spotMarket.decimals));
+    const thresholdNumber = parseFloat(cmdOpts.threshold);
+    const thresholdBN = numberToSafeBN(thresholdNumber, spotMarketPrecision);
+    let pendingProfitShareToRealize = ZERO;
+    const vdWithPendingProfitShare = vdWithNoWithdrawRequests.filter((vd: ProgramAccount<VaultDepositor>) => {
+        const pendingProfitShares = calculateApplyProfitShare(vd.account, vaultEquity, vault);
+        const doRealize = pendingProfitShares.profitShareAmount.gt(thresholdBN);
+        if (doRealize) {
+            pendingProfitShareToRealize = pendingProfitShareToRealize.add(pendingProfitShares.profitShareAmount);
+            return true;
+        } else {
+            return false;
+        }
+    });
+
+    console.log(`${vdWithPendingProfitShare.length}/${vdWithNoWithdrawRequests.length} depositors have pending profit shares above threshold ${cmdOpts.threshold} (${thresholdBN.toString()})`);
+    console.log(`Applying profit share for ${vdWithPendingProfitShare.length} depositors.`);
+
+    const chunkSize = 5;
     const ixChunks: Array<Array<TransactionInstruction>> = [];
-    for (let i = 0; i < vdToRealizeProfit.length; i += chunkSize) {
-        const chunk = vdToRealizeProfit.slice(i, i + chunkSize);
-        const ixs = await Promise.all(chunk.map((vaultDepositor) => {
-            return driftVault.getApplyProfitShareIx(vaultAddress, vaultDepositor.publicKey);
+    for (let i = 0; i < vdWithPendingProfitShare.length; i += chunkSize) {
+        const chunk = vdWithPendingProfitShare.slice(i, i + chunkSize);
+        const ixs = await Promise.all(chunk.map((vd: ProgramAccount<VaultDepositor>) => {
+            return driftVault.getApplyProfitShareIx(vaultAddress, vd.publicKey);
         }));
 
         ixChunks.push(ixs);
@@ -36,6 +63,7 @@ export const applyProfitShare = async (program: Command, cmdOpts: OptionValues)
 
     for (let i = 0; i < ixChunks.length; i++) {
         const ixs = ixChunks[i];
+        console.log(`Sending chunk ${i + 1}/${ixChunks.length}`);
         try {
             ixs.unshift(ComputeBudgetProgram.setComputeUnitLimit({
                 units: 1_400_000,

package/cli/commands/forceWithdraw.ts

@@ -4,21 +4,50 @@ import {
     Command
 } from "commander";
 import { getCommandContext } from "../utils";
+import { getVaultDepositorAddressSync } from "../../src/addresses";
+import { VAULT_PROGRAM_ID } from "../../src";
 
 export const forceWithdraw = async (program: Command, cmdOpts: OptionValues) => {
 
-    let vaultDepositorAddress: PublicKey;
+    let vaultDepositorAddress: PublicKey | undefined;
     try {
         vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositorAddress as string);
     } catch (err) {
-        console.error("Invalid vault depositor address");
-        process.exit(1);
+        console.error("Failed to parse vaultDepositorAddress trying vaultDepositorAuthority");
+    }
+
+    let vaultDepositorAuthority: PublicKey | undefined;
+    try {
+        vaultDepositorAuthority = new PublicKey(cmdOpts.vaultDepositorAuthority as string);
+    } catch (err) {
+        console.error("Failed to parse vaultDepositorAuthority");
+    }
+
+    if (!vaultDepositorAuthority && !vaultDepositorAddress) {
+        throw new Error("VaultDepositor address or authority must be provided");
+    }
+
+    let vaultAddress: PublicKey | undefined;
+    if (vaultDepositorAuthority && !vaultDepositorAddress) {
+        try {
+            vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+        } catch (err) {
+            throw new Error("Must provide --vault-address if only --vault-depositor-authority is provided");
+        }
+        vaultDepositorAddress = getVaultDepositorAddressSync(
+            VAULT_PROGRAM_ID,
+            vaultAddress,
+            vaultDepositorAuthority);
+    }
+
+    if (!vaultDepositorAddress) {
+        throw new Error("Failed to derive vault depositor address");
     }
 
     const {
         driftVault
     } = await getCommandContext(program, true);
 
-    const tx = await driftVault.forceWithdraw(vaultDepositorAddress);
+    const tx = await driftVault.forceWithdraw(vaultDepositorAddress, false);
     console.log(`Forced withdraw from vault: ${tx}`);
 };

package/cli/commands/managerRequestWithdraw.ts

@@ -1,4 +1,4 @@
-import { BN } from "@drift-labs/sdk";
+import { BN, TEN, decodeName, numberToSafeBN } from "@drift-labs/sdk";
 import { PublicKey } from "@solana/web3.js";
 import {
     OptionValues,
@@ -18,9 +18,35 @@ export const managerRequestWithdraw = async (program: Command, cmdOpts: OptionVa
     }
 
     const {
-        driftVault
+        driftClient, driftVault
     } = await getCommandContext(program, true);
 
-    const tx = await driftVault.managerRequestWithdraw(vaultAddress, new BN(cmdOpts.shares), WithdrawUnit.SHARES);
-    console.log(`Requested to withraw ${cmdOpts.shares} shares as vault manager: https://solscan.io/tx/${tx}`);
+    if (!cmdOpts.shares && !cmdOpts.amount) {
+        console.error("One of --shares or --amount must be provided.");
+        process.exit(1);
+    }
+
+    if (cmdOpts.shares && !cmdOpts.amount) {
+        const tx = await driftVault.managerRequestWithdraw(vaultAddress, new BN(cmdOpts.shares), WithdrawUnit.SHARES);
+        console.log(`Requested to withraw ${cmdOpts.shares} shares as vault manager: https://solscan.io/tx/${tx}`);
+    } else if (cmdOpts.amount && !cmdOpts.shares) {
+        const vault = await driftVault.getVault(vaultAddress);
+        const spotMarket = driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+        if (!spotMarket) {
+            console.error("Error: Spot market not found");
+            process.exit(1);
+        }
+        const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+        const amount = parseFloat(cmdOpts.amount);
+        const amountBN = numberToSafeBN(amount, spotPrecision);
+        console.log(amount);
+        console.log(amountBN.toString());
+        const tx = await driftVault.managerRequestWithdraw(vaultAddress, amountBN, WithdrawUnit.TOKEN);
+        console.log(`Requested to withdraw ${amount} ${decodeName(spotMarket.name)} as vault manager: https://solscan.io/tx/${tx}`);
+
+    } else {
+        console.error("Error: Either shares or amount must be provided, but not both.");
+        process.exit(1);
+    }
+
 };

package/cli/commands/managerUpdateVault.ts

@@ -1,4 +1,4 @@
-import { PublicKey } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey } from "@solana/web3.js";
 import {
     OptionValues,
     Command
@@ -119,6 +119,31 @@ export const managerUpdateVault = async (program: Command, cmdOpts: OptionValues
         permissioned,
     };
 
-    const tx = await driftVault.managerUpdateVault(vaultAddress, newParams);
-    console.log(`Updated vault params as vault manager: https://solscan.io/tx/${tx}`);
+    const preIxs = [
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 600_000,
+        }),
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: 100_000,
+        }),
+    ];
+
+    let done = false;
+    while (!done) {
+        try {
+            const tx = await driftVault.managerUpdateVault(vaultAddress, newParams, preIxs, { maxRetries: 0 });
+            console.log(`Updated vault params as vault manager: https://solana.fm/tx/${tx}`);
+            done = true;
+            break;
+        } catch (e) {
+            const err = e as Error;
+            if (err.message.includes('TransactionExpiredTimeoutError')) {
+                console.log(err.message);
+                console.log('Transaction timeout. Retrying...');
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            } else {
+                throw err;
+            }
+        }
+    }
 };

package/cli/commands/vaultInvariantChecks.ts

@@ -4,10 +4,11 @@ import {
     Command
 } from "commander";
 import { getCommandContext } from "../utils";
-import { BN, convertToNumber } from "@drift-labs/sdk";
+import { BN, QUOTE_PRECISION, ZERO, convertToNumber } from "@drift-labs/sdk";
 import {
     calculateApplyProfitShare,
 } from "../../src/math";
+import { VaultDepositor } from "../../src";
 
 export const vaultInvariantChecks = async (program: Command, cmdOpts: OptionValues) => {
 
@@ -37,42 +38,51 @@ export const vaultInvariantChecks = async (program: Command, cmdOpts: OptionValu
     const spotMarket = driftVault.driftClient.getSpotMarketAccount(vault.spotMarketIndex);
     const spotPrecision = new BN(10).pow(new BN(spotMarket!.decimals));
 
-    let allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    const allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    const approxSlot = await driftVault.driftClient.connection.getSlot();
+    const now = Date.now();
 
-    // Sort allVaultDepositors by vaultShares in descending order
-    allVaultDepositors = allVaultDepositors.sort((a, b) => b.account.vaultShares.cmp(a.account.vaultShares));
+    let nonZeroDepositors = allVaultDepositors.filter(vd => vd.account.vaultShares.gt(new BN(0)));
+    nonZeroDepositors = nonZeroDepositors.sort((a, b) => b.account.vaultShares.cmp(a.account.vaultShares));
 
     let totalUserShares = new BN(0);
     let totalUserProfitSharePaid = new BN(0);
     let totalUserProfitShareSharesPaid = new BN(0);
     let totalPendingProfitShareAmount = new BN(0);
+    let totalPendingProfitShareShares = new BN(0);
 
-    for (const vd of allVaultDepositors) {
-        totalUserShares = totalUserShares.add(vd.account.vaultShares);
-        if (!vd.account.lastWithdrawRequest.shares.eq(new BN(0))) {
-            const withdrawRequested = vd.account.lastWithdrawRequest.ts.toNumber();
+    console.log(`Vault ${vaultAddress} vd and invariant check at approx slot: ${approxSlot}, date: ${new Date(now).toLocaleString()}`);
+    console.log(`Depositors with 0 shares: ${allVaultDepositors.length - nonZeroDepositors.length}/${allVaultDepositors.length}`);
+    for (const vd of nonZeroDepositors) {
+        const vdAccount = vd.account as VaultDepositor;
+
+        totalUserShares = totalUserShares.add(vdAccount.vaultShares);
+        const vdAuth = vdAccount.authority.toBase58();
+        const vdPct = vdAccount.vaultShares.toNumber() / vault.totalShares.toNumber();
+        console.log(`- ${vdAuth} has ${vdAccount.vaultShares.toNumber()} shares (${(vdPct * 100.0).toFixed(2)}% of vault)`);
+
+        if (!vdAccount.lastWithdrawRequest.shares.eq(new BN(0))) {
+            const withdrawRequested = vdAccount.lastWithdrawRequest.ts.toNumber();
             const secToWithdrawal = withdrawRequested + vault.redeemPeriod.toNumber() - Date.now() / 1000;
             const withdrawAvailable = secToWithdrawal < 0;
-
-            const pct = vd.account.lastWithdrawRequest.shares.toNumber() / vd.account.vaultShares.toNumber();
-            console.log(`Vd has withdrawal ${vd.publicKey.toBase58()} (auth: ${vd.account.authority.toBase58()}): ${vd.account.lastWithdrawRequest.shares.toString()} ($${convertToNumber(vd.account.lastWithdrawRequest.value, spotPrecision)}), ${(pct * 100.00).toFixed(2)}%`);
-            console.log(`  - requested at: ${new Date(withdrawRequested * 1000).toISOString()}`);
+            const pct = vdAccount.lastWithdrawRequest.shares.toNumber() / vd.account.vaultShares.toNumber();
             const daysUntilWithdraw = Math.floor(secToWithdrawal / 86400);
             const hoursUntilWithdraw = Math.floor((secToWithdrawal % 86400) / 3600);
-            console.log(`  - can withdraw in: ${daysUntilWithdraw} days and ${hoursUntilWithdraw} hours ${withdrawAvailable ? "<--- WITHDRAWABLE" : ""}`);
-        }
 
-        if (!vd.account.cumulativeProfitShareAmount.eq(new BN(0))) {
-            // const profitSharePaid = vd.account.profitShareFeePaid.toNumber() / vd.account.cumulativeProfitShareAmount.toNumber();
-            // console.log(`Profit share paid: ${vd.publicKey.toBase58()} (auth: ${vd.account.authority.toBase58()}): ${Math.ceil(profitSharePaid * 100.0)}%`);
+            console.log(`  - pending withdrawal: ${vdAccount.lastWithdrawRequest.shares.toString()} ($${convertToNumber(vd.account.lastWithdrawRequest.value, spotPrecision)}), ${(pct * 100.00).toFixed(2)}% of their deposit ${withdrawAvailable ? "<--- WITHDRAWABLE" : ""}`);
+            console.log(`    - requested at: ${new Date(withdrawRequested * 1000).toISOString()}`);
+            console.log(`    - can withdraw in: ${daysUntilWithdraw} days and ${hoursUntilWithdraw} hours`);
         }
-        totalUserProfitSharePaid = totalUserProfitSharePaid.add(vd.account.profitShareFeePaid);
-        totalUserProfitShareSharesPaid = totalUserProfitShareSharesPaid.add(vd.account.cumulativeProfitShareAmount);
 
-        const pendingProfitShares = calculateApplyProfitShare(vd.account, vaultEquity, vault);
-        totalPendingProfitShareAmount = totalPendingProfitShareAmount.add(pendingProfitShares.profitShareAmount);
+        totalUserProfitSharePaid = totalUserProfitSharePaid.add(vdAccount.profitShareFeePaid);
+        totalUserProfitShareSharesPaid = totalUserProfitShareSharesPaid.add(vdAccount.cumulativeProfitShareAmount);
 
-        console.log(`Pending profit shares: ${vd.publicKey.toBase58()} (auth: ${vd.account.authority.toBase58()}): $${convertToNumber(pendingProfitShares.profitShareAmount, spotPrecision)}`);
+        const pendingProfitShares = calculateApplyProfitShare(vdAccount, vaultEquity, vault);
+        if (pendingProfitShares.profitShareAmount.gt(ZERO)) {
+            totalPendingProfitShareAmount = totalPendingProfitShareAmount.add(pendingProfitShares.profitShareAmount);
+            totalPendingProfitShareShares = totalPendingProfitShareShares.add(pendingProfitShares.profitShareShares);
+            console.log(`  - pending profit share amount: $${convertToNumber(pendingProfitShares.profitShareAmount, spotPrecision)}`);
+        }
     }
     console.log(`==== Vault Depositor Shares == vault.user_shares ====`);
     console.log(`total vd shares:        ${totalUserShares.toString()}`);
@@ -88,4 +98,17 @@ export const vaultInvariantChecks = async (program: Command, cmdOpts: OptionValu
     console.log(``);
     console.log(`==== Pending profit shares to realize ====`);
     console.log(`${convertToNumber(totalPendingProfitShareAmount, spotPrecision)}`);
+    console.log(`csv: ${cmdOpts.csv}`);
+
+    console.log(``);
+    console.log(`==== Manager share ====`);
+    console.log(`  Vault total shares: ${vault.totalShares.toNumber()}`);
+    const managerShares = vault.totalShares.sub(vault.userShares);
+    const managerSharePct = managerShares.toNumber() / vault.totalShares.toNumber();
+    const managerShareWithPendingPct = managerShares.add(totalPendingProfitShareShares).toNumber() / vault.totalShares.toNumber();
+    console.log(`  Manager shares: ${managerShares.toString()} (${(managerSharePct * 100.0).toFixed(4)}%)`);
+    const vaultEquityNum = convertToNumber(vaultEquity, QUOTE_PRECISION);
+    console.log(`vaultEquity (USDC):   $${vaultEquityNum}`);
+    console.log(`manager share (w/o pending) (USDC):  $${managerSharePct * vaultEquityNum}`);
+    console.log(`manager share (with pending) (USDC): $${managerShareWithPendingPct * vaultEquityNum}`);
 };

package/cli/commands/viewVault.ts

@@ -4,7 +4,6 @@ import {
     Command
 } from "commander";
 import { getCommandContext, printVault } from "../utils";
-import { BN, PRICE_PRECISION, QUOTE_PRECISION, TEN, convertToNumber, decodeName } from "@drift-labs/sdk";
 
 export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
 
@@ -22,12 +21,8 @@ export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
     } = await getCommandContext(program, false);
 
 
-    const vault = await driftVault.getVault(address);
-    const { managerSharePct } = printVault(vault);
-    const vaultEquity = await driftVault.calculateVaultEquity({
-        vault,
-    });
-
+    const vaultAndSlot = await driftVault.getVaultAndSlot(address);
+    const vault = vaultAndSlot.vault;
     const spotMarket = driftClient.getSpotMarketAccount(vault.spotMarketIndex);
     if (!spotMarket) {
         throw new Error(`Spot market ${vault.spotMarketIndex} not found`);
@@ -36,19 +31,9 @@ export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
     if (!spotOracle) {
         throw new Error(`Spot oracle ${vault.spotMarketIndex} not found`);
     }
-    const oraclePriceNum = convertToNumber(spotOracle.price, PRICE_PRECISION);
-    const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
-    const spotSymbol = decodeName(spotMarket.name);
-
-    const vaultEquityNum = convertToNumber(vaultEquity, QUOTE_PRECISION);
-    const netDepositsNum = convertToNumber(vault.netDeposits, spotPrecision);
-    console.log(`vaultEquity (USDC):   $${vaultEquityNum}`);
-    console.log(`manager share (USDC): $${managerSharePct * vaultEquityNum}`);
-    console.log(`vault PnL (USDC):     $${vaultEquityNum - netDepositsNum}`);
-
-    const vaultEquitySpot = vaultEquityNum / oraclePriceNum;
+    const vaultEquity = await driftVault.calculateVaultEquity({
+        vault,
+    });
+    await printVault(vaultAndSlot.slot, driftClient, vault, vaultEquity, spotMarket, spotOracle);
+};
 
-    console.log(`vaultEquity (${spotSymbol}):   ${vaultEquitySpot}`);
-    console.log(`manager share (${spotSymbol}): ${managerSharePct * vaultEquitySpot}`);
-    console.log(`vault PnL (${spotSymbol}):     ${vaultEquitySpot - netDepositsNum}`);
-};

package/cli/utils.ts

@@ -1,4 +1,4 @@
-import { DriftClient, Wallet, loadKeypair } from "@drift-labs/sdk";
+import { BASE_PRECISION, BN, DriftClient, OraclePriceData, PRICE_PRECISION, QUOTE_PRECISION, SpotMarketAccount, TEN, User, Wallet, convertToNumber, getSignedTokenAmount, getTokenAmount, loadKeypair } from "@drift-labs/sdk";
 import { VAULT_PROGRAM_ID, Vault, VaultClient, VaultDepositor, decodeName } from "../src";
 import { Command } from "commander";
 import { Connection, Keypair } from "@solana/web3.js";
@@ -6,7 +6,13 @@ import { AnchorProvider } from "@coral-xyz/anchor";
 import * as anchor from '@coral-xyz/anchor';
 import { IDL } from "../src/types/drift_vaults";
 
-export function printVault(vault: Vault) {
+export async function printVault(slot: number, driftClient: DriftClient, vault: Vault, vaultEquity: BN, spotMarket: SpotMarketAccount, spotOracle: OraclePriceData) {
+
+    const oraclePriceNum = convertToNumber(spotOracle.price, PRICE_PRECISION);
+    const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+    const spotSymbol = decodeName(spotMarket.name);
+
+    console.log(`slot: ${slot}`);
     console.log(`vault: ${decodeName(vault.name)}`);
     console.log(`pubkey:         ${vault.pubkey.toBase58()}`);
     console.log(`manager:         ${vault.manager.toBase58()}`);
@@ -25,21 +31,21 @@ export function printVault(vault: Vault) {
     console.log(`liquidationStartTs: ${vault.liquidationStartTs.toString()}`);
     console.log(`redeemPeriod:            ${vault.redeemPeriod.toString()}`);
     console.log(`totalWithdrawRequested:  ${vault.totalWithdrawRequested.toString()}`);
-    console.log(`maxTokens:               ${vault.maxTokens.toString()}`);
+    console.log(`maxTokens:               ${convertToNumber(vault.maxTokens, spotPrecision)} ${spotSymbol} (${vault.maxTokens.toString()})`);
     console.log(`sharesBase:              ${vault.sharesBase}`);
     console.log(`managementFee:           ${vault.managementFee.toString()}`);
     console.log(`initTs:                  ${vault.initTs.toString()}`);
-    console.log(`netDeposits:             ${vault.netDeposits.toString()}`);
-    console.log(`managerNetDeposits:      ${vault.managerNetDeposits.toString()}`);
-    console.log(`totalDeposits:           ${vault.totalDeposits.toString()}`);
-    console.log(`totalWithdraws:          ${vault.totalWithdraws.toString()}`);
-    console.log(`managerTotalDeposits:    ${vault.managerTotalDeposits.toString()}`);
-    console.log(`managerTotalWithdraws:   ${vault.managerTotalWithdraws.toString()}`);
-    console.log(`managerTotalFee:         ${vault.managerTotalFee.toString()}`);
-    console.log(`managerTotalProfitShare: ${vault.managerTotalProfitShare.toString()}`);
+    console.log(`netDeposits:             ${convertToNumber(vault.netDeposits, spotPrecision)} ${spotSymbol} (${vault.netDeposits.toString()})`);
+    console.log(`totalDeposits:           ${convertToNumber(vault.totalDeposits, spotPrecision)} ${spotSymbol} (${vault.totalDeposits.toString()})`);
+    console.log(`totalWithdraws:           ${convertToNumber(vault.totalWithdraws, spotPrecision)} ${spotSymbol} (${vault.totalWithdraws.toString()})`);
+    console.log(`managerNetDeposits:      ${convertToNumber(vault.managerNetDeposits, spotPrecision)} ${spotSymbol} (${vault.managerNetDeposits.toString()})`);
+    console.log(`managerTotalDeposits:    ${convertToNumber(vault.managerTotalDeposits, spotPrecision)} ${spotSymbol} (${vault.managerTotalDeposits.toString()})`);
+    console.log(`managerTotalWithdraws:   ${convertToNumber(vault.managerTotalWithdraws, spotPrecision)} ${spotSymbol} (${vault.managerTotalWithdraws.toString()})`);
+    console.log(`managerTotalFee:         ${convertToNumber(vault.managerTotalFee, spotPrecision)} ${spotSymbol} (${vault.managerTotalFee.toString()})`);
+    console.log(`managerTotalProfitShare: ${convertToNumber(vault.managerTotalProfitShare, spotPrecision)} ${spotSymbol} (${vault.managerTotalProfitShare.toString()})`);
     console.log(`lastManagerWithdrawRequest:`);
     console.log(`  shares: ${vault.lastManagerWithdrawRequest.shares.toString()}`);
-    console.log(`  values: ${vault.lastManagerWithdrawRequest.value.toString()}`);
+    console.log(`  values: ${convertToNumber(vault.lastManagerWithdrawRequest.value, spotPrecision)} ${spotSymbol} (${vault.lastManagerWithdrawRequest.value.toString()})`);
     console.log(`  ts:     ${vault.lastManagerWithdrawRequest.ts.toString()}`);
 
     console.log(`minDepositAmount:  ${vault.minDepositAmount.toString()}`);
@@ -48,6 +54,36 @@ export function printVault(vault: Vault) {
     console.log(`spotMarketIndex:   ${vault.spotMarketIndex}`);
     console.log(`permissioned:      ${vault.permissioned}`);
 
+    const vaultEquityNum = convertToNumber(vaultEquity, QUOTE_PRECISION);
+    const netDepositsNum = convertToNumber(vault.netDeposits, spotPrecision);
+    console.log(`vaultEquity (USDC):   $${vaultEquityNum}`);
+    console.log(`manager share (USDC): $${managerSharePct * vaultEquityNum}`);
+
+    const vaultEquitySpot = vaultEquityNum / oraclePriceNum;
+
+    const user = new User({
+        // accountSubscription,
+        driftClient,
+        userAccountPublicKey: vault.user,
+    });
+    await user.subscribe();
+    for (const spotPos of user.getActiveSpotPositions()) {
+        const sm = driftClient.getSpotMarketAccount(spotPos.marketIndex)!;
+        const prec = TEN.pow(new BN(sm.decimals));
+        const sym = decodeName(sm.name);
+        const bal = getSignedTokenAmount(getTokenAmount(spotPos.scaledBalance, sm, spotPos.balanceType), spotPos.balanceType);
+        console.log(`Spot Position: ${spotPos.marketIndex}, ${convertToNumber(bal, prec)} ${sym}`);
+    }
+    for (const perpPos of user.getActivePerpPositions()) {
+        console.log(`Perp Position: ${perpPos.marketIndex}, base: ${convertToNumber(perpPos.baseAssetAmount, BASE_PRECISION)}, quote: ${convertToNumber(perpPos.quoteAssetAmount, QUOTE_PRECISION)}`);
+        const upnl = user.getUnrealizedPNL(true, perpPos.marketIndex);
+        console.log(`  upnl: ${convertToNumber(upnl, QUOTE_PRECISION)}`);
+    }
+
+    console.log(`vaultEquity (${spotSymbol}):   ${vaultEquitySpot}`);
+    console.log(`manager share (${spotSymbol}): ${managerSharePct * vaultEquitySpot}`);
+    console.log(`vault PnL (${spotSymbol}):     ${vaultEquitySpot - netDepositsNum}`);
+
     return {
         managerShares,
         managerSharePct,

package/lib/vaultClient.d.ts

@@ -5,7 +5,7 @@ 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 { PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { ConfirmOptions, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { Vault, VaultDepositor, WithdrawUnit } from './types/types';
 import { UserMapConfig } from '@drift-labs/sdk/lib/userMap/userMapConfig';
 export type TxParams = {
@@ -93,7 +93,7 @@ export declare class VaultClient {
         profitShare: number | null;
         hurdleRate: number | null;
         permissioned: boolean | null;
-    }): Promise<TransactionSignature>;
+    }, preIxs?: Array<TransactionInstruction>, opts?: ConfirmOptions): Promise<TransactionSignature>;
     getApplyProfitShareIx(vault: PublicKey, vaultDepositor: PublicKey): Promise<TransactionInstruction>;
     private createInitVaultDepositorIx;
     /**
@@ -116,7 +116,7 @@ export declare class VaultClient {
     }): Promise<TransactionSignature>;
     requestWithdraw(vaultDepositor: PublicKey, amount: BN, withdrawUnit: WithdrawUnit): Promise<TransactionSignature>;
     withdraw(vaultDepositor: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
-    forceWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
+    forceWithdraw(vaultDepositor: PublicKey, ixOnly?: boolean, preIxs?: Array<TransactionInstruction>, simulate?: boolean, opts?: ConfirmOptions): Promise<TransactionSignature | TransactionInstruction | undefined>;
     cancelRequestWithdraw(vaultDepositor: PublicKey): Promise<TransactionSignature>;
     /**
      * Liquidates (become delegate for) a vault.

package/lib/vaultClient.js

@@ -319,14 +319,15 @@ class VaultClient {
             cuLimit: 1000000,
         });
     }
-    async managerUpdateVault(vault, params) {
-        return await this.program.methods
-            .updateVault(params)
-            .accounts({
+    async managerUpdateVault(vault, params, preIxs, opts) {
+        let builder = this.program.methods.updateVault(params).accounts({
             vault,
             manager: this.driftClient.wallet.publicKey,
-        })
-            .rpc();
+        });
+        if (preIxs) {
+            builder = builder.preInstructions(preIxs);
+        }
+        return builder.rpc(opts);
     }
     async getApplyProfitShareIx(vault, vaultDepositor) {
         const vaultAccount = await this.program.account.vault.fetch(vault);
@@ -560,7 +561,7 @@ class VaultClient {
             });
         }
     }
-    async forceWithdraw(vaultDepositor) {
+    async forceWithdraw(vaultDepositor, ixOnly, preIxs, simulate, opts) {
         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);
@@ -589,16 +590,52 @@ class VaultClient {
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         if (this.cliMode) {
-            return await this.program.methods
-                .forceWithdraw()
-                .preInstructions([
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: 400000,
-                }),
-            ])
-                .accounts(accounts)
-                .remainingAccounts(remainingAccounts)
-                .rpc();
+            if (ixOnly) {
+                return await this.program.methods
+                    .forceWithdraw()
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .instruction();
+            }
+            else if (simulate) {
+                let builder = this.program.methods.forceWithdraw();
+                if (preIxs) {
+                    builder = builder.preInstructions(preIxs);
+                }
+                else {
+                    builder = builder.preInstructions([
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                            units: 600000,
+                        }),
+                    ]);
+                }
+                const simResult = await builder
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .simulate();
+                console.log(simResult);
+                console.log(simResult.events);
+            }
+            else {
+                let builder = this.program.methods.forceWithdraw();
+                if (preIxs) {
+                    builder = builder.preInstructions(preIxs);
+                }
+                else {
+                    builder = builder.preInstructions([
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                            units: 600000,
+                        }),
+                        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: 100000,
+                        }),
+                    ]);
+                }
+                return await builder
+                    .accounts(accounts)
+                    .remainingAccounts(remainingAccounts)
+                    .rpc(opts);
+            }
         }
         else {
             const forceWithdrawIx = this.program.instruction.forceWithdraw({
@@ -698,7 +735,7 @@ class VaultClient {
                 units: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.cuLimit) !== null && _a !== void 0 ? _a : 400000,
             }),
             web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) !== null && _b !== void 0 ? _b : 1000000,
+                microLamports: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.cuPriceMicroLamports) !== null && _b !== void 0 ? _b : 80000,
             }),
             ...vaultIxs,
         ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/vaults-sdk",
-  "version": "0.1.211",
+  "version": "0.1.212",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "directories": {

package/src/vaultClient.ts

@@ -22,6 +22,7 @@ import {
 } from './addresses';
 import {
 	ComputeBudgetProgram,
+	ConfirmOptions,
 	PublicKey,
 	SystemProgram,
 	SYSVAR_RENT_PUBKEY,
@@ -524,15 +525,19 @@ export class VaultClient {
 			profitShare: number | null;
 			hurdleRate: number | null;
 			permissioned: boolean | null;
-		}
+		},
+		preIxs?: Array<TransactionInstruction>,
+		opts?: ConfirmOptions
 	): Promise<TransactionSignature> {
-		return await this.program.methods
-			.updateVault(params)
-			.accounts({
-				vault,
-				manager: this.driftClient.wallet.publicKey,
-			})
-			.rpc();
+		let builder = this.program.methods.updateVault(params).accounts({
+			vault,
+			manager: this.driftClient.wallet.publicKey,
+		});
+		if (preIxs) {
+			builder = builder.preInstructions(preIxs);
+		}
+
+		return builder.rpc(opts);
 	}
 
 	public async getApplyProfitShareIx(
@@ -887,8 +892,12 @@ export class VaultClient {
 	}
 
 	public async forceWithdraw(
-		vaultDepositor: PublicKey
-	): Promise<TransactionSignature> {
+		vaultDepositor: PublicKey,
+		ixOnly?: boolean,
+		preIxs?: Array<TransactionInstruction>,
+		simulate?: boolean,
+		opts?: ConfirmOptions
+	): Promise<TransactionSignature | TransactionInstruction | undefined> {
 		const vaultDepositorAccount =
 			await this.program.account.vaultDepositor.fetch(vaultDepositor);
 		const vaultAccount = await this.program.account.vault.fetch(
@@ -937,16 +946,49 @@ export class VaultClient {
 		};
 
 		if (this.cliMode) {
-			return await this.program.methods
-				.forceWithdraw()
-				.preInstructions([
-					ComputeBudgetProgram.setComputeUnitLimit({
-						units: 400_000,
-					}),
-				])
-				.accounts(accounts)
-				.remainingAccounts(remainingAccounts)
-				.rpc();
+			if (ixOnly) {
+				return await this.program.methods
+					.forceWithdraw()
+					.accounts(accounts)
+					.remainingAccounts(remainingAccounts)
+					.instruction();
+			} else if (simulate) {
+				let builder = this.program.methods.forceWithdraw();
+				if (preIxs) {
+					builder = builder.preInstructions(preIxs);
+				} else {
+					builder = builder.preInstructions([
+						ComputeBudgetProgram.setComputeUnitLimit({
+							units: 600_000,
+						}),
+					]);
+				}
+				const simResult = await builder
+					.accounts(accounts)
+					.remainingAccounts(remainingAccounts)
+					.simulate();
+
+				console.log(simResult);
+				console.log(simResult.events);
+			} else {
+				let builder = this.program.methods.forceWithdraw();
+				if (preIxs) {
+					builder = builder.preInstructions(preIxs);
+				} else {
+					builder = builder.preInstructions([
+						ComputeBudgetProgram.setComputeUnitLimit({
+							units: 600_000,
+						}),
+						ComputeBudgetProgram.setComputeUnitPrice({
+							microLamports: 100_000,
+						}),
+					]);
+				}
+				return await builder
+					.accounts(accounts)
+					.remainingAccounts(remainingAccounts)
+					.rpc(opts);
+			}
 		} else {
 			const forceWithdrawIx = this.program.instruction.forceWithdraw({
 				accounts: {
@@ -1076,7 +1118,7 @@ export class VaultClient {
 				units: txParams?.cuLimit ?? 400_000,
 			}),
 			ComputeBudgetProgram.setComputeUnitPrice({
-				microLamports: txParams?.cuPriceMicroLamports ?? 1_000_000,
+				microLamports: txParams?.cuPriceMicroLamports ?? 80_000,
 			}),
 			...vaultIxs,
 		];