@drift-labs/vaults-sdk 0.1.106 → 0.1.108

package/cli/cli.ts

@@ -17,6 +17,7 @@ import {
     listDepositorsForVault,
     managerUpdateMarginTradingEnabled,
     decodeLogs,
+    vaultInvariantChecks,
 } from "./commands";
 
 import { Command, Option } from 'commander';
@@ -147,6 +148,11 @@ program
     .description("Decode program logs from a txid")
     .addOption(new Option("--tx <tx>", "Transaction hash").makeOptionMandatory(true))
     .action((opts) => decodeLogs(program, opts));
+program
+    .command("check-invariants")
+    .description("Perform sanity checks on vault/depositor invariants")
+    .addOption(new Option("--vault-address <address>", "Vault address").makeOptionMandatory(true))
+    .action((opts) => vaultInvariantChecks(program, opts));
 
 program.parseAsync().then(() => {
     process.exit(0);

package/cli/commands/applyProfitShare.ts

@@ -1,4 +1,4 @@
-import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
 import {
     OptionValues,
     Command
@@ -19,27 +19,45 @@ export const applyProfitShare = async (program: Command, cmdOpts: OptionValues)
         driftVault
     } = await getCommandContext(program, true);
 
-    const allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
-    // console.log(allVaultDepositors);
-
-    console.log(`Cranking profit share for ${allVaultDepositors.length} depositors...`);
+    const vdToRealizeProfit = await driftVault.getAllVaultDepositorsWithNoWithdrawRequest(vaultAddress);
+    console.log(`Applying profit share for ${vdToRealizeProfit.length} depositors...`);
 
     const chunkSize = 10;
     const ixChunks: Array<Array<TransactionInstruction>> = [];
-    for (let i = 0; i < allVaultDepositors.length; i += chunkSize) {
-        const chunk = allVaultDepositors.slice(i, i + chunkSize);
+    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);
         }));
 
         ixChunks.push(ixs);
     }
-    console.log(`Cranking ${ixChunks.length} of ${chunkSize} depositors at a time...`);
+    console.log(`Sending ${ixChunks.length} transactions...`);
+
+    for (let i = 0; i < ixChunks.length; i++) {
+        const ixs = ixChunks[i];
+        try {
+            ixs.unshift(ComputeBudgetProgram.setComputeUnitLimit({
+                units: 1_400_000,
+            }));
+            ixs.unshift(ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 100,
+            }));
+
+            const tx = new Transaction();
+            tx.add(...ixs);
+            const { txSig } = await driftVault.driftClient.sendTransaction(
+                tx,
+                [],
+                driftVault.driftClient.opts
+            );
+
+            console.log(`[${i}]: https://solscan.io/tx/${txSig}`);
+
+        } catch (e) {
+            console.error(e);
+            continue;
+        }
 
-    const txs = await Promise.all(ixChunks.map((ixs) => driftVault.createAndSendTxn(ixs, {
-        units: 2_000_000
-    })));
-    for (const tx of txs) {
-        console.log(`Crank tx: https://solscan.io/tx/${tx}`);
     }
 };

package/cli/commands/index.ts

@@ -15,4 +15,6 @@ export * from './forceWithdraw';
 export * from './withdraw';
 export * from './listDepositorsForVault';
 export * from './managerUpdateMarginTradingEnabled';
-export * from './decodeLogs';
+export * from './decodeLogs';
+export * from './vaultInvariantChecks';
+

package/cli/commands/vaultInvariantChecks.ts

@@ -0,0 +1,72 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { BN, convertToNumber } from "@drift-labs/sdk";
+import {
+    calculateApplyProfitShare,
+} from "../../src/math";
+
+export const vaultInvariantChecks = async (program: Command, cmdOpts: OptionValues) => {
+
+    let vaultAddress: PublicKey;
+    try {
+        vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+    } catch (err) {
+        console.error("Invalid vault address");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    /*
+    Invariants:
+    * sum(vault_depositors.shares) == vault.user_shares
+    * sum(vault_depositors.profit_share_paid) == vault.manager_total_profit_share
+    */
+
+
+    const vault = await driftVault.getVault(vaultAddress);
+    const vaultEquity = await driftVault.calculateVaultEquity({
+        vault,
+    });
+    const spotMarket = driftVault.driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+    const spotPrecision = new BN(10).pow(new BN(spotMarket!.decimals));
+
+    const allVaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+
+    let totalUserShares = new BN(0);
+    let totalUserProfitSharePaid = new BN(0);
+
+    for (const vd of allVaultDepositors) {
+        totalUserShares = totalUserShares.add(vd.account.vaultShares);
+        if (!vd.account.lastWithdrawRequest.shares.eq(new BN(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)}%`);
+        }
+
+        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)}%`);
+        }
+        totalUserProfitSharePaid = totalUserProfitSharePaid.add(vd.account.profitShareFeePaid);
+
+        const pendingProfitShares = calculateApplyProfitShare(vd.account, vaultEquity, vault);
+        console.log(`Pending profit shares: ${vd.publicKey.toBase58()} (auth: ${vd.account.authority.toBase58()}): $${convertToNumber(pendingProfitShares.profitShareAmount, spotPrecision)}`);
+        console.log(` . ${pendingProfitShares.profitShareShares}, ${pendingProfitShares.profitShareAmount}`);
+    }
+    console.log(`==== Vault Depositor Shares == vault.user_shares ====`);
+    console.log(`total vd shares:        ${totalUserShares.toString()}`);
+    console.log(`total vault usershares: ${vault.userShares.toString()}`);
+    console.log(`diff: ${vault.userShares.sub(totalUserShares)}`);
+
+    console.log(``);
+    console.log(`==== Vault Depositor ProfitSharePaid == vault.manager_total_profit_share ====`);
+    console.log(`total vault d profitshares: ${totalUserProfitSharePaid.toString()}`);
+    console.log(`vault total profit shares:  ${vault.managerTotalProfitShare.toString()}`);
+    console.log(`diff: ${vault.managerTotalProfitShare.sub(totalUserProfitSharePaid)}`);
+};

package/cli/commands/viewVault.ts

@@ -4,7 +4,7 @@ import {
     Command
 } from "commander";
 import { getCommandContext, printVault } from "../utils";
-import { QUOTE_PRECISION, convertToNumber } from "@drift-labs/sdk";
+import { BN, PRICE_PRECISION, QUOTE_PRECISION, TEN, convertToNumber, decodeName } from "@drift-labs/sdk";
 
 export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
 
@@ -17,14 +17,38 @@ export const viewVault = async (program: Command, cmdOpts: OptionValues) => {
     }
 
     const {
-        driftVault
+        driftVault,
+        driftClient,
     } = await getCommandContext(program, false);
 
+
     const vault = await driftVault.getVault(address);
     const { managerSharePct } = printVault(vault);
     const vaultEquity = await driftVault.calculateVaultEquity({
         vault,
     });
-    console.log(`vaultEquity: $${convertToNumber(vaultEquity, QUOTE_PRECISION)}`);
-    console.log(`manager share: $${managerSharePct * convertToNumber(vaultEquity, QUOTE_PRECISION)}`);
+
+    const spotMarket = driftClient.getSpotMarketAccount(vault.spotMarketIndex);
+    if (!spotMarket) {
+        throw new Error(`Spot market ${vault.spotMarketIndex} not found`);
+    }
+    const spotOracle = driftClient.getOracleDataForSpotMarket(vault.spotMarketIndex);
+    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;
+
+    console.log(`vaultEquity (${spotSymbol}):   ${vaultEquitySpot}`);
+    console.log(`manager share (${spotSymbol}): ${managerSharePct * vaultEquitySpot}`);
+    console.log(`vault PnL (${spotSymbol}):     ${vaultEquitySpot - netDepositsNum}`);
 };

package/lib/index.d.ts

@@ -8,3 +8,4 @@ export * from './types/types';
 export * from './constants';
 export * from './parsers';
 export * from './types/drift_vaults';
+export * from './math';

package/lib/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./types/types"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./parsers"), exports);
 __exportStar(require("./types/drift_vaults"), exports);
+__exportStar(require("./math"), exports);

package/lib/math/index.d.ts

@@ -0,0 +1 @@
+export * from './vaultDepositor';

package/lib/math/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaultDepositor"), exports);

package/lib/math/vaultDepositor.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="bn.js" />
+import { BN } from '@drift-labs/sdk';
+import { Vault, VaultDepositor } from '../types/types';
+/**
+ * Calculates the unrealized profitShare for a vaultDepositor
+ * @param vaultDepositor
+ * @param vaultEquity
+ * @param vault
+ * @returns
+ */
+export declare function calculateApplyProfitShare(vaultDepositor: VaultDepositor, vaultEquity: BN, vault: Vault): {
+    profitShareAmount: BN;
+    profitShareShares: BN;
+};
+export declare function calculateProfitShare(vaultDepositor: VaultDepositor, totalAmount: BN, vault: Vault): BN;

package/lib/math/vaultDepositor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateProfitShare = exports.calculateApplyProfitShare = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+/**
+ * Calculates the unrealized profitShare for a vaultDepositor
+ * @param vaultDepositor
+ * @param vaultEquity
+ * @param vault
+ * @returns
+ */
+function calculateApplyProfitShare(vaultDepositor, vaultEquity, vault) {
+    const amount = (0, sdk_1.unstakeSharesToAmount)(vaultDepositor.vaultShares, vault.totalShares, vaultEquity);
+    const profitShareAmount = calculateProfitShare(vaultDepositor, amount, vault);
+    const profitShareShares = (0, sdk_1.stakeAmountToShares)(profitShareAmount, vault.totalShares, vaultEquity);
+    return {
+        profitShareAmount,
+        profitShareShares,
+    };
+}
+exports.calculateApplyProfitShare = calculateApplyProfitShare;
+function calculateProfitShare(vaultDepositor, totalAmount, vault) {
+    const profit = totalAmount.sub(vaultDepositor.netDeposits.add(vaultDepositor.cumulativeProfitShareAmount));
+    if (profit.gt(sdk_1.ZERO)) {
+        const profitShareAmount = profit
+            .mul(new sdk_1.BN(vault.profitShare))
+            .div(sdk_1.PERCENTAGE_PRECISION);
+        return profitShareAmount;
+    }
+    return sdk_1.ZERO;
+}
+exports.calculateProfitShare = calculateProfitShare;

package/lib/vaultClient.d.ts

@@ -18,6 +18,7 @@ export declare class VaultClient {
     });
     getVault(vault: PublicKey): Promise<Vault>;
     getVaultDepositor(vaultDepositor: PublicKey): Promise<any>;
+    getAllVaultDepositorsWithNoWithdrawRequest(vault: PublicKey): Promise<ProgramAccount<VaultDepositor>[]>;
     getAllVaultDepositors(vault: PublicKey): Promise<ProgramAccount<VaultDepositor>[]>;
     /**
      *

package/lib/vaultClient.js

@@ -21,7 +21,7 @@ class VaultClient {
     async getVaultDepositor(vaultDepositor) {
         return await this.program.account.vaultDepositor.fetch(vaultDepositor);
     }
-    async getAllVaultDepositors(vault) {
+    async getAllVaultDepositorsWithNoWithdrawRequest(vault) {
         const filters = [
             {
                 // discriminator = VaultDepositor
@@ -38,10 +38,30 @@ class VaultClient {
                 },
             },
             {
-                // last_withdraw_request_ts = 0
+                // last_withdraw_request.shares (u128) = 0
                 memcmp: {
-                    offset: 144,
-                    bytes: bytes_1.bs58.encode(Uint8Array.from([0])),
+                    offset: 112,
+                    bytes: bytes_1.bs58.encode(new Uint8Array(16).fill(0)),
+                },
+            },
+        ];
+        // @ts-ignore
+        return (await this.program.account.vaultDepositor.all(filters));
+    }
+    async getAllVaultDepositors(vault) {
+        const filters = [
+            {
+                // discriminator = VaultDepositor
+                memcmp: {
+                    offset: 0,
+                    bytes: bytes_1.bs58.encode(anchor_1.BorshAccountsCoder.accountDiscriminator('VaultDepositor')),
+                },
+            },
+            {
+                // vault = vault
+                memcmp: {
+                    offset: 8,
+                    bytes: vault.toBase58(),
                 },
             },
         ];

package/package.json

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

package/src/index.ts

@@ -8,3 +8,4 @@ export * from './types/types';
 export * from './constants';
 export * from './parsers';
 export * from './types/drift_vaults';
+export * from './math';

package/src/math/index.ts

@@ -0,0 +1 @@
+export * from './vaultDepositor';

package/src/math/vaultDepositor.ts

@@ -0,0 +1,58 @@
+import {
+	BN,
+	PERCENTAGE_PRECISION,
+	ZERO,
+	unstakeSharesToAmount as depositSharesToVaultAmount,
+	stakeAmountToShares as vaultAmountToDepositorShares,
+} from '@drift-labs/sdk';
+import { Vault, VaultDepositor } from '../types/types';
+
+/**
+ * Calculates the unrealized profitShare for a vaultDepositor
+ * @param vaultDepositor
+ * @param vaultEquity
+ * @param vault
+ * @returns
+ */
+export function calculateApplyProfitShare(
+	vaultDepositor: VaultDepositor,
+	vaultEquity: BN,
+	vault: Vault
+): {
+	profitShareAmount: BN;
+	profitShareShares: BN;
+} {
+	const amount = depositSharesToVaultAmount(
+		vaultDepositor.vaultShares,
+		vault.totalShares,
+		vaultEquity
+	);
+	const profitShareAmount = calculateProfitShare(vaultDepositor, amount, vault);
+	const profitShareShares = vaultAmountToDepositorShares(
+		profitShareAmount,
+		vault.totalShares,
+		vaultEquity
+	);
+	return {
+		profitShareAmount,
+		profitShareShares,
+	};
+}
+
+export function calculateProfitShare(
+	vaultDepositor: VaultDepositor,
+	totalAmount: BN,
+	vault: Vault
+) {
+	const profit = totalAmount.sub(
+		vaultDepositor.netDeposits.add(vaultDepositor.cumulativeProfitShareAmount)
+	);
+	if (profit.gt(ZERO)) {
+		const profitShareAmount = profit
+			.mul(new BN(vault.profitShare))
+			.div(PERCENTAGE_PRECISION);
+		return profitShareAmount;
+	}
+
+	return ZERO;
+}

package/src/vaultClient.ts

@@ -65,7 +65,7 @@ export class VaultClient {
 		return await this.program.account.vaultDepositor.fetch(vaultDepositor);
 	}
 
-	public async getAllVaultDepositors(
+	public async getAllVaultDepositorsWithNoWithdrawRequest(
 		vault: PublicKey
 	): Promise<ProgramAccount<VaultDepositor>[]> {
 		const filters = [
@@ -86,10 +86,37 @@ export class VaultClient {
 				},
 			},
 			{
-				// last_withdraw_request_ts = 0
+				// last_withdraw_request.shares (u128) = 0
+				memcmp: {
+					offset: 112,
+					bytes: bs58.encode(new Uint8Array(16).fill(0)),
+				},
+			},
+		];
+		// @ts-ignore
+		return (await this.program.account.vaultDepositor.all(
+			filters
+		)) as ProgramAccount<VaultDepositor>[];
+	}
+
+	public async getAllVaultDepositors(
+		vault: PublicKey
+	): Promise<ProgramAccount<VaultDepositor>[]> {
+		const filters = [
+			{
+				// discriminator = VaultDepositor
+				memcmp: {
+					offset: 0,
+					bytes: bs58.encode(
+						BorshAccountsCoder.accountDiscriminator('VaultDepositor')
+					),
+				},
+			},
+			{
+				// vault = vault
 				memcmp: {
-					offset: 144,
-					bytes: bs58.encode(Uint8Array.from([0])),
+					offset: 8,
+					bytes: vault.toBase58(),
 				},
 			},
 		];