@velocity-exchange/vaults-sdk 0.0.1

package/cli/commands/adminDeleteFeeUpdate.ts

@@ -0,0 +1,73 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { dumpTransactionMessage, getCommandContext } from "../utils";
+import { VAULT_ADMIN_KEY } from "../../src";
+
+export const adminDeleteFeeUpdate = 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,
+        driftClient,
+    } = await getCommandContext(program, true);
+
+    if (!driftClient.wallet.publicKey.equals(VAULT_ADMIN_KEY)) {
+        console.error("Only vault admin can delete fee update");
+        process.exit(1);
+    }
+
+    const vault = await driftVault.getVault(vaultAddress);
+
+    console.log(`Deleting fee update for vault:`);
+    console.log(`  Vault: ${vault.pubkey.toBase58()}`);
+
+    const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    console.log('');
+    const answer = await new Promise(resolve => {
+        readline.question('Are you sure you want to delete the fee update? (yes/no) ', (answer: string) => {
+            readline.close();
+            resolve(answer);
+        });
+    });
+    if ((answer as string).toLowerCase() !== 'yes') {
+        console.log('Fee update deletion canceled.');
+        process.exit(0);
+    }
+    console.log('Deleting fee update...');
+
+    let done = false;
+    while (!done) {
+        try {
+            if (cmdOpts.dumpTransactionMessage) {
+                const tx = await driftVault.getAdminDeleteFeeUpdateIx(vaultAddress);
+                console.log(dumpTransactionMessage(driftClient.wallet.publicKey, [tx]));
+            } else {
+                const tx = await driftVault.adminDeleteFeeUpdate(vaultAddress);
+                console.log(`Deleted fee update as admin: https://solana.fm/tx/${tx}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+                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/adminInitFeeUpdate.ts

@@ -0,0 +1,73 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { dumpTransactionMessage, getCommandContext } from "../utils";
+import { VAULT_ADMIN_KEY } from "../../src";
+
+export const adminInitFeeUpdate = 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,
+        driftClient,
+    } = await getCommandContext(program, true);
+
+    if (!driftClient.wallet.publicKey.equals(VAULT_ADMIN_KEY)) {
+        console.error("Only vault admin can initialize fee update");
+        process.exit(1);
+    }
+
+    const vault = await driftVault.getVault(vaultAddress);
+
+    console.log(`Initializing fee update for vault:`);
+    console.log(`  Vault: ${vault.pubkey.toBase58()}`);
+
+    const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    console.log('');
+    const answer = await new Promise(resolve => {
+        readline.question('Is the above information correct? (yes/no) ', (answer: string) => {
+            readline.close();
+            resolve(answer);
+        });
+    });
+    if ((answer as string).toLowerCase() !== 'yes') {
+        console.log('Fee update initialization canceled.');
+        process.exit(0);
+    }
+    console.log('Initializing fee update...');
+
+    let done = false;
+    while (!done) {
+        try {
+            if (cmdOpts.dumpTransactionMessage) {
+                const tx = await driftVault.getAdminInitFeeUpdateIx(vaultAddress);
+                console.log(dumpTransactionMessage(driftClient.wallet.publicKey, [tx]));
+            } else {
+                const tx = await driftVault.adminInitFeeUpdate(vaultAddress);
+                console.log(`Initialized fee update as admin: https://solana.fm/tx/${tx}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+                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/adminUpdateVaultClass.ts

@@ -0,0 +1,49 @@
+import { Command, OptionValues } from "commander";
+import { PublicKey } from "@solana/web3.js";
+import { VaultClass } from "../../src";
+import { dumpTransactionMessage, getCommandContext } from "../utils";
+
+export async function adminUpdateVaultClass(program: Command, cmdOpts: OptionValues): Promise<void> {
+    const { vaultAddress, vaultClass, dumpTransactionMessage: dumpTx } = cmdOpts;
+
+    const {
+        driftClient,
+        driftVault
+    } = await getCommandContext(program, true);
+
+    if (!vaultAddress) {
+        throw new Error("Must provide vault address with --vault-address");
+    }
+
+    if (!vaultClass) {
+        throw new Error("Must provide vault class with --vault-class");
+    }
+
+    const vault = new PublicKey(vaultAddress);
+    
+    // Parse vault class from string input
+    let newVaultClass: VaultClass;
+    switch (vaultClass.toLowerCase()) {
+        case 'trusted':
+            newVaultClass = VaultClass.TRUSTED;
+            break;
+        default:
+            throw new Error(`Invalid vault class: ${vaultClass}. Must be 'trusted'`);
+    }
+
+    try {
+        if (dumpTx) {
+            const ix = await driftVault.getAdminUpdateVaultClassIx(vault, newVaultClass);
+            console.log("Transaction Instruction:");
+            console.log(dumpTransactionMessage(driftClient.wallet.publicKey, [ix]));
+            return;
+        }
+
+        const txSig = await driftVault.adminUpdateVaultClass(vault, newVaultClass);
+        console.log(`Admin update vault class transaction signature: ${txSig}`);
+        console.log(`Transaction: https://solana.fm/tx/${txSig}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+    } catch (error) {
+        console.error("Error updating vault class:", error);
+        throw error;
+    }
+} 

package/cli/commands/applyProfitShare.ts

@@ -0,0 +1,139 @@
+import {
+	ComputeBudgetProgram,
+	PublicKey,
+	SendTransactionError,
+	TransactionInstruction,
+	TransactionMessage,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { OptionValues, Command } from 'commander';
+import { getCommandContext } from '../utils';
+import { VaultDepositor, calculateApplyProfitShare } from '../../src';
+import { BN, TEN, ZERO, numberToSafeBN } from '@velocity-exchange/sdk';
+import { ProgramAccount } from '@coral-xyz/anchor';
+
+export const applyProfitShare = 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, driftClient, wallet } = await getCommandContext(
+		program,
+		true
+	);
+
+	const vault = await driftVault.getVault(vaultAddress);
+	const vdWithNoWithdrawRequests =
+		await driftVault.getAllVaultDepositorsWithNoWithdrawRequest(vaultAddress);
+	const vaultEquitySpot = await driftVault.calculateVaultEquityInDepositAsset({
+		vault,
+	});
+
+	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>) => {
+			if (vault.managementFee.gt(ZERO)) {
+				return true;
+			}
+			const pendingProfitShares = calculateApplyProfitShare(
+				vd.account,
+				vaultEquitySpot,
+				vault
+			);
+			const doRealize = pendingProfitShares.profitShareAmount.gte(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 = 1;
+	const ixChunks: Array<Array<TransactionInstruction>> = [];
+	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);
+	}
+	console.log(`Sending ${ixChunks.length} transactions...`);
+
+	for (let i = 0; i < ixChunks.length; i++) {
+		const ixs = ixChunks[i];
+		console.log(`Sending chunk ${i + 1}/${ixChunks.length}`);
+		try {
+			ixs.unshift(
+				ComputeBudgetProgram.setComputeUnitPrice({
+					microLamports: 10000,
+				})
+			);
+			ixs.unshift(
+				ComputeBudgetProgram.setComputeUnitLimit({
+					units: 170_000,
+				})
+			);
+
+			const message = new TransactionMessage({
+				payerKey: driftClient.wallet.publicKey,
+				recentBlockhash: (
+					await driftClient.connection.getLatestBlockhash('finalized')
+				).blockhash,
+				instructions: ixs,
+			}).compileToV0Message();
+
+			const tx = await wallet.signVersionedTransaction(
+				new VersionedTransaction(message)
+			);
+
+			try {
+				const txid = await driftClient.connection.sendTransaction(tx);
+				console.log(
+					`Sent chunk: https://solana.fm/tx/${txid}${
+						driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+					}`
+				);
+			} catch (e) {
+				console.error(`Error sending chunk: ${e}`);
+				console.log((e as SendTransactionError).logs);
+			}
+		} catch (e) {
+			console.error(e);
+			continue;
+		}
+	}
+};

package/cli/commands/decodeLogs.ts

@@ -0,0 +1,98 @@
+import { OptionValues, Command } from 'commander';
+import { getCommandContext } from '../utils';
+import { VaultDepositorRecord } from '../../src';
+import { BN, TEN, convertToNumber, getVariant } from '@velocity-exchange/sdk';
+
+export const decodeLogs = async (program: Command, cmdOpts: OptionValues) => {
+	let txId: string;
+	try {
+		txId = cmdOpts.tx as string;
+	} catch (err) {
+		console.error('Invalid transaction hash');
+		process.exit(1);
+	}
+	if (!txId) {
+		console.error('Invalid transaction hash');
+		process.exit(1);
+	}
+
+	const { driftVault, driftClient } = await getCommandContext(program, false);
+
+	const tx = await driftClient.connection.getParsedTransaction(txId, {
+		commitment: 'confirmed',
+		maxSupportedTransactionVersion: 0,
+	});
+
+	let i = 0;
+	// @ts-ignore
+	for (const event of driftVault.program._events._eventParser.parseLogs(
+		tx!.meta!.logMessages
+	)) {
+		console.log(`--------------- Event: ${i} ${event.name} -----------------`);
+		i++;
+
+		/* eslint-disable no-case-declarations */
+		switch (event.name) {
+			case 'VaultDepositorRecord':
+				const data: VaultDepositorRecord = event.data;
+				const spotMarket = driftClient.getSpotMarketAccount(
+					data.spotMarketIndex
+				);
+				const spotPrecision = TEN.pow(new BN(spotMarket!.decimals));
+				const date = new Date(data.ts.toNumber() * 1000);
+
+				console.log(event.name);
+				console.log(` ts: ${date.toISOString()} (${data.ts.toNumber()})`);
+				console.log(` vault:              ${data.vault.toBase58()}`);
+				console.log(
+					` depositorAuthority: ${data.depositorAuthority.toBase58()}`
+				);
+				console.log(` action: ${getVariant(data.action)}`);
+				console.log(` amount: ${convertToNumber(data.amount, spotPrecision)}`);
+				console.log(` vaultSharesBefore: ${data.vaultSharesBefore.toNumber()}`);
+				console.log(
+					` vaultSharesAfter:  ${data.vaultSharesAfter.toNumber()} (${
+						data.vaultSharesAfter.toNumber() - data.vaultSharesBefore.toNumber()
+					})`
+				);
+				console.log(
+					` vaultEquityBefore:     ${convertToNumber(
+						data.vaultEquityBefore,
+						spotPrecision
+					)}`
+				);
+				console.log(
+					` userVaultSharesBefore: ${data.userVaultSharesBefore.toNumber()}`
+				);
+				console.log(
+					` userVaultSharesAfter:  ${data.userVaultSharesAfter.toNumber()} (${
+						data.userVaultSharesAfter.toNumber() -
+						data.userVaultSharesBefore.toNumber()
+					})`
+				);
+				console.log(
+					` totalVaultSharesBefore: ${data.totalVaultSharesBefore.toNumber()}`
+				);
+				console.log(
+					` totalVaultSharesAfter:  ${data.totalVaultSharesAfter.toNumber()} (${
+						data.totalVaultSharesAfter.toNumber() -
+						data.totalVaultSharesBefore.toNumber()
+					})`
+				);
+				console.log(` profitShare:    ${data.profitShare.toNumber()}`);
+				console.log(` managementFee:  ${data.managementFee.toNumber()}`);
+				console.log(
+					` managementFeeShares:  ${data.managementFeeShares.toNumber()}`
+				);
+				// @ts-ignore
+				console.log(
+					` depositOraclePrice:  ${data.depositOraclePrice?.toNumber()}`
+				);
+				break;
+			default:
+		}
+
+		console.log('----------Raw Event-------------');
+		console.log(event);
+	}
+};

package/cli/commands/deposit.ts

@@ -0,0 +1,98 @@
+import { BN, TEN } from '@velocity-exchange/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { OptionValues, Command } from 'commander';
+import { getCommandContext } from '../utils';
+import { getVaultDepositorAddressSync, VAULT_PROGRAM_ID } from '../../src';
+
+export const deposit = async (program: Command, cmdOpts: OptionValues) => {
+	// verify correct args provided
+	if (!cmdOpts.vaultDepositorAddress) {
+		if (!cmdOpts.vaultAddress || !cmdOpts.depositAuthority) {
+			console.error(
+				'Must provide --vault-address and --deposit-authority if not providing --vault-depositor-address'
+			);
+			process.exit(1);
+		}
+	}
+
+	const { driftClient, driftVault } = await getCommandContext(program, true);
+
+	let vaultDepositorAddress: PublicKey;
+	let vaultAddress: PublicKey | undefined;
+	let depositAuthority: PublicKey | undefined;
+	if (cmdOpts.vaultDepositorAddress) {
+		vaultDepositorAddress = new PublicKey(
+			cmdOpts.vaultDepositorAddress as string
+		);
+	} else {
+		vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+		depositAuthority = new PublicKey(cmdOpts.depositAuthority as string);
+		vaultDepositorAddress = getVaultDepositorAddressSync(
+			VAULT_PROGRAM_ID,
+			vaultAddress,
+			depositAuthority
+		);
+	}
+
+	const vaultDepositorAccount =
+		await driftVault.program.account.vaultDepositor.fetchNullable(
+			vaultDepositorAddress
+		);
+	if (!vaultDepositorAccount) {
+		if (!vaultAddress || !depositAuthority) {
+			console.error(
+				'Must provide --vault-address and --deposit-authority if not providing --vault-depositor-address, and VaultDepositor account does not exist'
+			);
+			process.exit(1);
+		}
+
+		const vaultAccount = await driftVault.program.account.vault.fetch(
+			vaultAddress
+		);
+		const spotMarket = driftClient.getSpotMarketAccount(
+			vaultAccount.spotMarketIndex
+		);
+		if (!spotMarket) {
+			throw new Error('No spot market found');
+		}
+		const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+		const depositBN = new BN(cmdOpts.amount * spotPrecision.toNumber());
+
+		console.log(
+			`depositing (initializing VaultDepositor account): ${depositBN.toString()}`
+		);
+		const tx = await driftVault.deposit(vaultDepositorAddress, depositBN, {
+			authority: depositAuthority,
+			vault: vaultAddress,
+		});
+		console.log(
+			`Deposited ${cmdOpts.amount} to vault: https://solana.fm/tx/${tx}${
+				driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+			}`
+		);
+	} else {
+		// VaultDepositor exists
+		const vaultAddress = vaultDepositorAccount.vault;
+		const vaultAccount = await driftVault.program.account.vault.fetch(
+			vaultAddress
+		);
+		const spotMarket = driftClient.getSpotMarketAccount(
+			vaultAccount.spotMarketIndex
+		);
+		if (!spotMarket) {
+			throw new Error('No spot market found');
+		}
+		const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+		const depositBN = new BN(cmdOpts.amount * spotPrecision.toNumber());
+
+		console.log(
+			`depositing (existing VaultDepositor account): ${depositBN.toString()}`
+		);
+		const tx = await driftVault.deposit(vaultDepositorAddress, depositBN);
+		console.log(
+			`Deposited ${cmdOpts.amount} to vault: https://solana.fm/tx/${tx}${
+				driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+			}`
+		);
+	}
+};

package/cli/commands/deriveVaultAddress.ts

@@ -0,0 +1,14 @@
+import { OptionValues, Command } from 'commander';
+import { encodeName } from '@velocity-exchange/sdk';
+import { VAULT_PROGRAM_ID, getVaultAddressSync } from '../../src';
+
+export const deriveVaultAddress = async (
+	_program: Command,
+	cmdOpts: OptionValues
+) => {
+	const vaultName = cmdOpts.vaultName;
+	const vaultNameBytes = encodeName(vaultName!);
+	const vaultAddress = getVaultAddressSync(VAULT_PROGRAM_ID, vaultNameBytes);
+
+	console.log(`Vault address: ${vaultAddress.toBase58()}`);
+};

package/cli/commands/forceWithdraw.ts

@@ -0,0 +1,56 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    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 | undefined;
+    try {
+        vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositorAddress as string);
+    } catch (err) {
+        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,
+        driftClient,
+    } = await getCommandContext(program, true);
+
+    const tx = await driftVault.forceWithdraw(vaultDepositorAddress, {
+        lookupTables: await driftClient.fetchAllLookupTableAccounts()
+    });
+    console.log(`Forced withdraw from vault: ${tx}`);
+};