@velocity-exchange/vaults-sdk 0.0.1

package/cli/commands/forceWithdrawAll.ts

@@ -0,0 +1,142 @@
+import {
+	ComputeBudgetProgram,
+	PublicKey,
+	SendTransactionError,
+	TransactionInstruction,
+	TransactionMessage,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { OptionValues, Command } from 'commander';
+import { getCommandContext } from '../utils';
+import { VaultDepositor } from '../../src';
+import { BN, convertToNumber } from '@velocity-exchange/sdk';
+import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes';
+
+export const forceWithdrawAll = async (
+	program: Command,
+	cmdOpts: OptionValues
+) => {
+	let vaultAddress: PublicKey | undefined;
+	try {
+		vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+	} catch (err) {
+		throw new Error('Must provide --vault-address');
+	}
+
+	if (!vaultAddress) {
+		throw new Error('Failed to derive vault depositor address');
+	}
+
+	const { driftVault, driftClient, wallet } = await getCommandContext(
+		program,
+		true
+	);
+
+	const vault = await driftVault.getVault(vaultAddress);
+	const allVaultDepositors = await driftVault.getAllVaultDepositors(
+		vaultAddress
+	);
+	const spotMarket = driftVault.driftClient.getSpotMarketAccount(
+		vault.spotMarketIndex
+	);
+	const spotPrecision = new BN(10).pow(new BN(spotMarket!.decimals));
+
+	const withdrawables: Array<PublicKey> = [];
+	for (const vd of allVaultDepositors) {
+		const vdAccount = vd.account as VaultDepositor;
+		if (vdAccount.lastWithdrawRequest.shares.gt(new BN(0))) {
+			const withdrawRequested = vdAccount.lastWithdrawRequest.ts.toNumber();
+			const secToWithdrawal =
+				withdrawRequested + vault.redeemPeriod.toNumber() - Date.now() / 1000;
+			const withdrawAvailable = secToWithdrawal < 0;
+			const pct =
+				vdAccount.lastWithdrawRequest.shares.toNumber() /
+				vd.account.vaultShares.toNumber();
+			const daysUntilWithdraw = Math.floor(secToWithdrawal / 86400);
+			const hoursUntilWithdraw = Math.floor((secToWithdrawal % 86400) / 3600);
+
+			if (secToWithdrawal < 0) {
+				console.log(`Withdraw available for ${vdAccount.authority.toBase58()}`);
+				console.log(
+					`  - pending withdrawal: ${vdAccount.lastWithdrawRequest.shares.toString()} ($${convertToNumber(
+						vd.account.lastWithdrawRequest.value,
+						spotPrecision
+					)}), ${(pct * 100.0).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`
+				);
+				withdrawables.push(vdAccount.pubkey);
+			}
+		}
+	}
+
+	console.log(`Withdrawing ${withdrawables.length} depositors`);
+	const luts = await driftClient.fetchAllLookupTableAccounts();
+	const chunkSize = 1;
+	for (let i = 0; i < withdrawables.length; i += chunkSize) {
+		const chunk = withdrawables.slice(i, i + chunkSize);
+		console.log(
+			`Processing chunk ${i / chunkSize + 1} of ${Math.ceil(
+				withdrawables.length / chunkSize
+			)}`
+		);
+		const ixs: TransactionInstruction[] = [
+			new TransactionInstruction({
+				keys: [{ pubkey: wallet.publicKey, isSigner: true, isWritable: true }],
+				data: Buffer.from('Drift Vaults manager initiated withdrawal', 'utf-8'),
+				programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+			}),
+		];
+		for (const depositorAddress of chunk) {
+			try {
+				console.log(`Trying deposit: ${depositorAddress.toBase58()}`);
+				ixs.push(...(await driftVault.getForceWithdrawIx(depositorAddress)));
+			} catch (error) {
+				console.error(
+					`Error withdrawing for ${depositorAddress.toBase58()}:`,
+					error
+				);
+			}
+		}
+
+		const message = new TransactionMessage({
+			payerKey: driftClient.wallet.publicKey,
+			recentBlockhash: (
+				await driftClient.connection.getLatestBlockhash('finalized')
+			).blockhash,
+			instructions: [
+				ComputeBudgetProgram.setComputeUnitLimit({
+					units: 800_000,
+				}),
+				ComputeBudgetProgram.setComputeUnitPrice({
+					microLamports: 10_000,
+				}),
+				...ixs,
+			],
+		}).compileToV0Message(luts);
+
+		const tx = await wallet.signVersionedTransaction(
+			new VersionedTransaction(message)
+		);
+
+		console.log(`Sending chunk: ${bs58.encode(tx.signatures[0])}`);
+		try {
+			const txid = await driftClient.connection.sendTransaction(tx);
+			console.log(`Sent chunk: https://solana.fm/tx/${txid}`);
+		} catch (e) {
+			console.error(`Error sending chunk: ${e}`);
+			console.log((e as SendTransactionError).logs);
+		}
+	}
+
+	// const tx = await driftVault.forceWithdraw(vaultDepositorAddress);
+	// console.log(`Forced withdraw from vault: ${tx}`);
+};

package/cli/commands/index.ts

@@ -0,0 +1,28 @@
+export * from './initVault';
+export * from './viewVault';
+export * from './deriveVaultAddress';
+export * from './managerDeposit';
+export * from './managerRequestWithdraw';
+export * from './managerCancelWithdraw';
+export * from './managerWithdraw';
+export * from './managerUpdateVault';
+export * from './managerUpdateVaultManager';
+export * from './managerUpdateVaultDelegate';
+export * from './applyProfitShare';
+export * from './initVaultDepositor';
+export * from './deposit';
+export * from './requestWithdraw';
+export * from './forceWithdraw';
+export * from './forceWithdrawAll';
+export * from './withdraw';
+export * from './listDepositorsForVault';
+export * from './managerUpdateMarginTradingEnabled';
+export * from './decodeLogs';
+export * from './vaultInvariantChecks';
+export * from './adminInitFeeUpdate';
+export * from './adminDeleteFeeUpdate';
+export * from './managerBorrow';
+export * from './managerRepay';
+export * from './managerUpdateBorrow';
+export * from './adminUpdateVaultClass';
+

package/cli/commands/initVault.ts

@@ -0,0 +1,227 @@
+import {
+	BN,
+	PERCENTAGE_PRECISION,
+	PublicKey,
+	TEN,
+	convertToNumber,
+	decodeName,
+	getSignedMsgUserAccountPublicKey,
+	getUserAccountPublicKey,
+} from '@velocity-exchange/sdk';
+import { OptionValues, Command } from 'commander';
+import { encodeName, getVaultAddressSync } from '../../src';
+import { dumpTransactionMessage, getCommandContext } from '../utils';
+import { VAULT_PROGRAM_ID } from '../../src/types/types';
+
+export const initVault = async (program: Command, cmdOpts: OptionValues) => {
+	const { driftClient, driftVault } = await getCommandContext(program, true);
+
+	const newVaultName = cmdOpts.name;
+	if (!newVaultName) {
+		throw new Error('Must provide vault name with -n/--name');
+	}
+	const vaultNameBytes = encodeName(newVaultName!);
+
+	let spotMarketIndex = cmdOpts.marketIndex;
+	if (!spotMarketIndex) {
+		spotMarketIndex = '0';
+	}
+	spotMarketIndex = parseInt(spotMarketIndex);
+	const spotMarket = driftClient.getSpotMarketAccount(spotMarketIndex);
+	if (!spotMarket) {
+		throw new Error('No spot market found');
+	}
+	const spotPrecision = TEN.pow(new BN(spotMarket.decimals));
+	const spotMarketName = decodeName(spotMarket.name);
+
+	let redeemPeriodSec = cmdOpts.redeemPeriod;
+	if (!redeemPeriodSec) {
+		redeemPeriodSec = (7 * 60 * 60 * 24).toString(); // 7 days
+	}
+	redeemPeriodSec = parseInt(redeemPeriodSec);
+
+	let maxTokens = cmdOpts.maxTokens;
+	if (!maxTokens) {
+		maxTokens = '0';
+	}
+	maxTokens = parseInt(maxTokens);
+	const maxTokensBN = new BN(maxTokens).mul(spotPrecision);
+
+	let managementFee = cmdOpts.managementFee;
+	if (!managementFee) {
+		managementFee = '0';
+	}
+	managementFee = parseInt(managementFee);
+	const managementFeeBN = new BN(managementFee)
+		.mul(PERCENTAGE_PRECISION)
+		.div(new BN(100));
+
+	let profitShare = cmdOpts.profitShare;
+	if (!profitShare) {
+		profitShare = '0';
+	}
+	profitShare = parseInt(profitShare);
+	const profitShareBN = new BN(profitShare)
+		.mul(PERCENTAGE_PRECISION)
+		.div(new BN(100));
+
+	let permissioned = cmdOpts.permissioned;
+	if (!permissioned) {
+		permissioned = false;
+	}
+
+	let minDepositAmount = cmdOpts.minDepositAmount;
+	if (!minDepositAmount) {
+		minDepositAmount = '0';
+	}
+	minDepositAmount = parseFloat(minDepositAmount);
+	const minDepositAmountBN = new BN(
+		spotPrecision.toNumber() * minDepositAmount
+	);
+
+	let delegate = cmdOpts.delegate;
+	if (!delegate) {
+		delegate = driftClient.wallet.publicKey;
+	} else {
+		try {
+			delegate = new PublicKey(delegate);
+		} catch (err) {
+			console.error(`Invalid delegate address: ${err}`);
+			delegate = driftClient.wallet.publicKey;
+		}
+	}
+
+	console.log(`Initializing a new vault with params:`);
+	console.log(`  VaultName:              ${newVaultName}`);
+	console.log(
+		`  DepositSpotMarketIndex: ${spotMarketIndex} (${spotMarketName})`
+	);
+	console.log(
+		`  MaxTokens:              ${convertToNumber(
+			maxTokensBN,
+			spotPrecision
+		)} ${spotMarketName}`
+	);
+	console.log(
+		`  MinDepositAmount:       ${convertToNumber(
+			minDepositAmountBN,
+			spotPrecision
+		)} ${spotMarketName}`
+	);
+	console.log(
+		`  ManagementFee:          ${
+			convertToNumber(managementFeeBN, PERCENTAGE_PRECISION) * 100.0
+		}%`
+	);
+	console.log(
+		`  ProfitShare:            ${
+			convertToNumber(profitShareBN, PERCENTAGE_PRECISION) * 100.0
+		}%`
+	);
+	console.log(`  Permissioned:           ${permissioned}`);
+	console.log(`  Delegate:               ${delegate.toBase58()}`);
+	console.log(
+		`  Manager:                ${
+			cmdOpts.manager
+				? cmdOpts.manager
+				: driftClient.wallet.publicKey.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('Initialization cancelled.');
+		readline.close();
+		process.exit(0);
+	}
+
+	const vaultAddress = getVaultAddressSync(VAULT_PROGRAM_ID, vaultNameBytes);
+	const vaultDriftUser = await getUserAccountPublicKey(
+		driftClient.program.programId,
+		vaultAddress,
+		0
+	);
+
+	const ixs = [
+		await driftVault.getInitializeVaultIx({
+			name: vaultNameBytes,
+			spotMarketIndex,
+			redeemPeriod: new BN(redeemPeriodSec),
+			maxTokens: maxTokensBN,
+			managementFee: managementFeeBN,
+			profitShare: profitShareBN.toNumber(),
+			hurdleRate: 0,
+			permissioned,
+			minDepositAmount: minDepositAmountBN,
+			manager: cmdOpts.manager,
+		}),
+		await driftVault.getUpdateDelegateIx(
+			vaultAddress,
+			delegate,
+			vaultDriftUser,
+			cmdOpts.manager
+		),
+	];
+
+	const signedOrdersAccountAddress = getSignedMsgUserAccountPublicKey(
+		driftClient.program.programId,
+		vaultAddress
+	);
+
+	let swiftUsersAccountExists = false;
+	try {
+		const acc = await driftClient.connection.getAccountInfo(
+			signedOrdersAccountAddress
+		);
+		swiftUsersAccountExists = acc !== null;
+	} catch (_err) {
+		// Error getting account info is non-critical, default to false
+	}
+
+	if (!swiftUsersAccountExists) {
+		ixs.push(
+			(
+				await driftClient.getInitializeSignedMsgUserOrdersAccountIx(
+					vaultAddress,
+					8
+				)
+			)[1]
+		);
+	}
+
+	console.log(`New vault address will be: ${vaultAddress.toBase58()}`);
+	console.log(`Setting trading delegate to: ${delegate.toBase58()}`);
+	console.log('');
+
+	if (cmdOpts.dumpTransactionMessage) {
+		console.log(`Base 58 encoded transaction:`);
+		console.log(
+			dumpTransactionMessage(
+				cmdOpts.manager
+					? new PublicKey(cmdOpts.manager)
+					: driftClient.wallet.publicKey,
+				ixs
+			)
+		);
+	} else {
+		const initTx = await driftVault.createAndSendTxn(ixs);
+		console.log(
+			`Initialized vault, tx: https://solana.fm/tx/${initTx}${
+				driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+			}`
+		);
+	}
+};

package/cli/commands/initVaultDepositor.ts

@@ -0,0 +1,42 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    getVaultDepositorAddressSync
+} from "../../src/addresses";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+import { VAULT_PROGRAM_ID } from "../../src/types/types";
+
+export const initVaultDepositor = 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);
+    }
+
+    let depositAuthority: PublicKey;
+    try {
+        depositAuthority = new PublicKey(cmdOpts.depositAuthority as string);
+    } catch (err) {
+        console.error("Invalid deposit authority");
+        process.exit(1);
+    }
+
+    const {
+        driftVault
+    } = await getCommandContext(program, true);
+
+    const vaultDepositorAddress = getVaultDepositorAddressSync(
+        VAULT_PROGRAM_ID,
+        vaultAddress,
+        depositAuthority,
+    );
+    const tx = await driftVault.initializeVaultDepositor(vaultAddress, depositAuthority, driftVault.driftClient.wallet.publicKey);
+    console.log(`VaultDepositor initialized for ${depositAuthority}: ${tx}`);
+    console.log(`VaultDepositor address: ${vaultDepositorAddress}`);
+};

package/cli/commands/listDepositorsForVault.ts

@@ -0,0 +1,32 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { getCommandContext } from "../utils";
+
+export const listDepositorsForVault = async (program: Command, cmdOpts: OptionValues) => {
+
+    const {
+        driftVault
+    } = await getCommandContext(program, false);
+
+    let vaultAddress: PublicKey | undefined = undefined;
+    try {
+        if (cmdOpts.vaultAddress !== undefined) {
+            vaultAddress = new PublicKey(cmdOpts.vaultAddress as string);
+        } else {
+            console.error("Must supply --vault-address");
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error("Failed to load VaultDepositor address");
+        process.exit(1);
+    }
+
+    const vaultDepositors = await driftVault.getAllVaultDepositors(vaultAddress);
+    vaultDepositors.forEach((vaultDepositor) => {
+        console.log(vaultDepositor.publicKey.toBase58());
+    });
+    // printVaultDepositor(vaultDepositor);
+};

package/cli/commands/managerApplyProfitShare.ts

@@ -0,0 +1,32 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { dumpTransactionMessage, getCommandContext } from "../utils";
+
+export const managerApplyProfitShare = 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);
+
+    const vaultDepositorAddress = new PublicKey(cmdOpts.vaultDepositor as string);
+
+    if (cmdOpts.dumpTransactionMessage) {
+        const tx = await driftVault.getApplyProfitShareIx(vaultAddress, vaultDepositorAddress);
+        console.log(dumpTransactionMessage(driftClient.wallet.publicKey, [tx]));
+    } else {
+        const tx = await driftVault.applyProfitShare(vaultAddress, vaultDepositorAddress);
+        console.log(`Applied profit share: https://solana.fm/tx/${tx}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+    }
+};

package/cli/commands/managerBorrow.ts

@@ -0,0 +1,77 @@
+import { Command, OptionValues } from 'commander';
+import { PublicKey } from '@solana/web3.js';
+import { BN, TEN } from '@velocity-exchange/sdk';
+import { dumpTransactionMessage, getCommandContext } from '../utils';
+
+export async function managerBorrow(
+	program: Command,
+	cmdOpts: OptionValues
+): Promise<void> {
+	const {
+		vaultAddress,
+		borrowSpotMarketIndex,
+		borrowAmount,
+		managerTokenAccount,
+		dumpTransactionMessage: dumpTx,
+	} = cmdOpts;
+
+	const { driftClient, driftVault } = await getCommandContext(program, true);
+
+	if (!vaultAddress) {
+		throw new Error('Must provide vault address with --vault-address');
+	}
+
+	if (!borrowSpotMarketIndex) {
+		throw new Error(
+			'Must provide borrow spot market index with --borrow-spot-market-index'
+		);
+	}
+
+	if (!borrowAmount) {
+		throw new Error('Must provide borrow amount with --borrow-amount');
+	}
+
+	const vault = new PublicKey(vaultAddress);
+	const borrowIndex = parseInt(borrowSpotMarketIndex);
+
+	const borrowSpotMarket = driftClient.getSpotMarketAccount(borrowIndex);
+	if (!borrowSpotMarket) {
+		throw new Error('No borrow spot market found');
+	}
+	const borrowPrecision = TEN.pow(new BN(borrowSpotMarket.decimals));
+	const borrowBN = new BN(borrowAmount * borrowPrecision.toNumber());
+
+	const managerTokenAccountPubkey = managerTokenAccount
+		? new PublicKey(managerTokenAccount)
+		: undefined;
+
+	try {
+		if (dumpTx) {
+			const ixs = await driftVault.getManagerBorrowIx(
+				vault,
+				borrowIndex,
+				borrowBN,
+				managerTokenAccountPubkey
+			);
+			console.log('Transaction Instructions:');
+			console.log(dumpTransactionMessage(driftClient.wallet.publicKey, ixs));
+			return;
+		}
+
+		const txSig = await driftVault.managerBorrow(
+			vault,
+			borrowIndex,
+			borrowBN,
+			managerTokenAccountPubkey
+		);
+		console.log(`Manager borrow transaction signature: ${txSig}`);
+		console.log(
+			`Transaction: https://solana.fm/tx/${txSig}${
+				driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+			}`
+		);
+	} catch (error) {
+		console.error('Error borrowing:', error);
+		throw error;
+	}
+}

package/cli/commands/managerCancelWithdraw.ts

@@ -0,0 +1,30 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+    OptionValues,
+    Command
+} from "commander";
+import { dumpTransactionMessage, getCommandContext } from "../utils";
+
+export const managerCancelWithdraw = 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 (cmdOpts.dumpTransactionMessage) {
+        const tx = await driftVault.getManagerCancelWithdrawRequestIx(vaultAddress);
+        console.log(dumpTransactionMessage(driftClient.wallet.publicKey, [tx]));
+    } else {
+        const tx = await driftVault.managerCancelWithdrawRequest(vaultAddress);
+        console.log(`Canceled withdraw as vault manager: https://solana.fm/tx/${tx}${driftClient.env === "devnet" ? "?cluster=devnet-solana" : ""}`);
+    }
+};

package/cli/commands/managerDeposit.ts

@@ -0,0 +1,45 @@
+import { BN, TEN } from '@velocity-exchange/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { OptionValues, Command } from 'commander';
+import { dumpTransactionMessage, getCommandContext } from '../utils';
+
+export const managerDeposit = 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 { driftClient, driftVault } = await getCommandContext(program, true);
+
+	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());
+
+	if (cmdOpts.dumpTransactionMessage) {
+		const txs = await driftVault.getManagerDepositIx(vaultAddress, depositBN);
+		console.log(dumpTransactionMessage(driftClient.wallet.publicKey, txs));
+	} else {
+		const tx = await driftVault.managerDeposit(vaultAddress, depositBN);
+		console.log(
+			`Deposited ${
+				cmdOpts.amount
+			} to vault as manager: https://solana.fm/tx/${tx}${
+				driftClient.env === 'devnet' ? '?cluster=devnet-solana' : ''
+			}`
+		);
+	}
+};