@velocity-exchange/vaults-sdk 0.0.1

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@velocity-exchange/vaults-sdk",
+	"version": "0.0.1",
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
+	"directories": {
+		"lib": "lib"
+	},
+	"dependencies": {
+		"@metaplex-foundation/js": "0.20.1",
+		"@velocity-exchange/sdk": "0.0.3",
+		"commander": "11.1.0",
+		"dotenv": "16.4.5",
+		"strict-event-emitter-types": "2.0.0",
+		"ts-node": "10.9.2",
+		"typescript": "5.6.3"
+	},
+	"peerDependencies": {
+		"@coral-xyz/anchor": "npm:@anchor-lang/core@1.0.1",
+		"@solana/web3.js": "1.98.0"
+	},
+	"optionalDependencies": {
+		"@ledgerhq/hw-app-solana": "7.2.4",
+		"@ledgerhq/hw-transport": "6.31.4",
+		"@ledgerhq/hw-transport-node-hid": "6.29.5",
+		"@solana/wallet-adapter-ledger": "0.9.25"
+	},
+	"devDependencies": {
+		"@coral-xyz/anchor": "npm:@anchor-lang/core@1.0.1",
+		"@types/bn.js": "5.1.6"
+	},
+	"engines": {
+		"node": "^24.0.0"
+	},
+	"scripts": {
+		"cli": "ts-node cli/cli.ts",
+		"clean": "rm -rf lib",
+		"build": "yarn clean && tsc"
+	},
+	"resolutions": {
+		"@types/bn.js": "5.1.6",
+		"rpc-websockets": "10.0.0",
+		"@solana/web3.js": "1.98.0",
+		"@drift-labs/sdk": "npm:@velocity-exchange/sdk@0.0.3",
+		"@velocity-exchange/sdk": "0.0.3",
+		"@coral-xyz/anchor": "npm:@anchor-lang/core@1.0.1"
+	}
+}

package/src/accountSubscribers/index.ts

@@ -0,0 +1,2 @@
+export * from './pollingVaultDepositorSubscriber';
+export * from './pollingVaultSubscriber';

package/src/accountSubscribers/pollingVaultDepositorSubscriber.ts

@@ -0,0 +1,69 @@
+import {
+	VaultDepositor,
+	VaultDepositorAccountEvents,
+	VaultDepositorAccountSubscriber,
+} from '../types/types';
+import { PollingVaultsProgramAccountSubscriber } from './pollingVaultsProgramAccountSubscriber';
+
+export class PollingVaultDepositorSubscriber
+	extends PollingVaultsProgramAccountSubscriber<
+		VaultDepositor,
+		VaultDepositorAccountEvents
+	>
+	implements VaultDepositorAccountSubscriber
+{
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			console.log(
+				'Account for vault depositor already added to account loader'
+			);
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.pubkey,
+			(buffer, slot) => {
+				if (!buffer) return;
+
+				if (this.account && this.account.slot > slot) {
+					return;
+				}
+
+				const account =
+					this.program.account.vaultDepositor.coder.accounts.decode(
+						'vaultDepositor',
+						buffer
+					);
+				this.account = { data: account, slot };
+				this._eventEmitter.emit('vaultDepositorUpdate', account);
+				this._eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this._eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		const bufferAndSlot = this.accountLoader.getBufferAndSlot(this.pubkey);
+		if (!bufferAndSlot) return;
+		const currentSlot = this.account?.slot ?? 0;
+		if (bufferAndSlot.buffer && bufferAndSlot.slot > currentSlot) {
+			const account = this.program.account.vaultDepositor.coder.accounts.decode(
+				'vaultDepositor',
+				bufferAndSlot.buffer
+			);
+			this.account = { data: account, slot: bufferAndSlot.slot };
+		}
+	}
+
+	updateData(vaultDepositorAcc: VaultDepositor, slot: number): void {
+		if (!this.account || this.account.slot < slot) {
+			this.account = { data: vaultDepositorAcc, slot };
+			this._eventEmitter.emit('vaultDepositorUpdate', vaultDepositorAcc);
+			this._eventEmitter.emit('update');
+		}
+	}
+}

package/src/accountSubscribers/pollingVaultSubscriber.ts

@@ -0,0 +1,63 @@
+import {
+	Vault,
+	VaultAccountEvents,
+	VaultAccountSubscriber,
+} from '../types/types';
+import { PollingVaultsProgramAccountSubscriber } from './pollingVaultsProgramAccountSubscriber';
+
+export class PollingVaultSubscriber
+	extends PollingVaultsProgramAccountSubscriber<Vault, VaultAccountEvents>
+	implements VaultAccountSubscriber
+{
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			console.log('Account for vault already added to account loader');
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.pubkey,
+			(buffer, slot) => {
+				if (!buffer) return;
+
+				if (this.account && this.account.slot > slot) {
+					return;
+				}
+
+				const account = this.program.account.vault.coder.accounts.decode(
+					'vault',
+					buffer
+				);
+				this.account = { data: account, slot };
+				this._eventEmitter.emit('vaultUpdate', account);
+				this._eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this._eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		const bufferAndSlot = this.accountLoader.getBufferAndSlot(this.pubkey);
+		if (!bufferAndSlot) return;
+		const currentSlot = this.account?.slot ?? 0;
+		if (bufferAndSlot.buffer && bufferAndSlot.slot > currentSlot) {
+			const account = this.program.account.vault.coder.accounts.decode(
+				'vault',
+				bufferAndSlot.buffer
+			);
+			this.account = { data: account, slot: bufferAndSlot.slot };
+		}
+	}
+
+	updateData(vaultAcc: Vault, slot: number): void {
+		if (!this.account || this.account.slot < slot) {
+			this.account = { data: vaultAcc, slot };
+			this._eventEmitter.emit('vaultUpdate', vaultAcc);
+			this._eventEmitter.emit('update');
+		}
+	}
+}

package/src/accountSubscribers/pollingVaultsProgramAccountSubscriber.ts

@@ -0,0 +1,114 @@
+import {
+	BulkAccountLoader,
+	DataAndSlot,
+	NotSubscribedError,
+	PublicKey,
+} from '@velocity-exchange/sdk';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { DriftVaults } from '../types/drift_vaults';
+import {
+	VaultsProgramAccountBaseEvents,
+	VaultsProgramAccountSubscriber,
+} from '../types/types';
+
+export abstract class PollingVaultsProgramAccountSubscriber<
+	Account,
+	AccountEvents extends VaultsProgramAccountBaseEvents
+> implements VaultsProgramAccountSubscriber<Account, AccountEvents>
+{
+	protected program: Program<DriftVaults>;
+	protected _isSubscribed: boolean;
+	protected pubkey: PublicKey;
+	protected account?: DataAndSlot<Account>;
+
+	protected _eventEmitter: StrictEventEmitter<EventEmitter, AccountEvents>;
+	protected accountLoader: BulkAccountLoader;
+	protected callbackId: string | null = null;
+	protected errorCallbackId: string | null = null;
+
+	constructor(
+		program: Program<DriftVaults>,
+		accountPubkey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.accountLoader = accountLoader;
+		this._isSubscribed = false;
+		this.pubkey = accountPubkey;
+		this.program = program;
+		// @ts-ignore
+		this._eventEmitter = new EventEmitter();
+	}
+
+	get isSubscribed(): boolean {
+		return this._isSubscribed;
+	}
+
+	get eventEmitter(): StrictEventEmitter<EventEmitter, AccountEvents> {
+		return this._eventEmitter;
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this._isSubscribed) {
+			return true;
+		}
+
+		try {
+			await this.addToAccountLoader();
+
+			await this.fetchIfUnloaded();
+			if (this.account) {
+				// @ts-ignore
+				this._eventEmitter.emit('update');
+			}
+
+			this._isSubscribed = true;
+			return true;
+		} catch (err) {
+			console.error(err);
+			this._isSubscribed = false;
+			return false;
+		}
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this._isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(this.pubkey, this.callbackId!);
+		this.callbackId = null;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId!);
+		this.errorCallbackId = null;
+
+		this._isSubscribed = false;
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.account === undefined) {
+			await this.fetch();
+		}
+	}
+
+	assertIsSubscribed(): void {
+		if (!this._isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	getAccountAndSlot(): DataAndSlot<Account> {
+		this.assertIsSubscribed();
+		if (!this.account) {
+			throw new Error('Account not loaded');
+		}
+		return this.account;
+	}
+
+	abstract addToAccountLoader(): Promise<void>;
+	abstract fetch(): Promise<void>;
+	abstract updateData(account: Account, slot: number): void;
+}

package/src/accounts/index.ts

@@ -0,0 +1,2 @@
+export * from './vaultDepositorAccount';
+export * from './vaultAccount';

package/src/accounts/vaultAccount.ts

@@ -0,0 +1,255 @@
+import { Program } from '@coral-xyz/anchor';
+import {
+	BulkAccountLoader,
+	ONE,
+	ONE_YEAR,
+	PERCENTAGE_PRECISION,
+	ZERO,
+	BN,
+} from '@velocity-exchange/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { DriftVaults } from '../types/drift_vaults';
+import { Vault, VaultAccountEvents, VaultProtocol } from '../types/types';
+import { PollingVaultSubscriber } from '../accountSubscribers';
+import { VaultsProgramAccount } from './vaultsProgramAccount';
+import { getVaultAddressSync } from '../addresses';
+import { encodeName } from '../name';
+
+export class VaultAccount extends VaultsProgramAccount<
+	Vault,
+	VaultAccountEvents
+> {
+	constructor(
+		program: Program<DriftVaults>,
+		vaultPubkey: PublicKey,
+		accountLoader: BulkAccountLoader,
+		accountSubscriptionType: 'polling' | 'websocket' = 'polling'
+	) {
+		super();
+
+		if (accountSubscriptionType === 'polling') {
+			this.accountSubscriber = new PollingVaultSubscriber(
+				program,
+				vaultPubkey,
+				accountLoader
+			);
+		} else {
+			throw new Error('Websocket subscription not yet implemented');
+		}
+	}
+
+	static getAddressSync(programId: PublicKey, vaultName: string): PublicKey {
+		return getVaultAddressSync(programId, encodeName(vaultName));
+	}
+
+	/**
+	 * Calculates the new total shares and management fee shares after a management fee is applied.
+	 * Only applies to deposits.
+	 * Management fee is applied to a depositor's existing equity, and the total shares are updated (increased) accordingly.
+	 * @param vaultEquity - The equity of the vault.
+	 * @returns An object containing the new total shares and management fee shares.
+	 */
+	calcSharesAfterManagementFee(vaultEquity: BN): {
+		totalShares: BN;
+		managementFeeShares: BN;
+	} {
+		const accountData = this.accountSubscriber.getAccountAndSlot().data;
+
+		const depositorsEquity = accountData.userShares
+			.mul(vaultEquity)
+			.div(accountData.totalShares);
+
+		if (accountData.managementFee.eq(ZERO) || depositorsEquity.lte(ZERO)) {
+			return {
+				totalShares: accountData.totalShares,
+				managementFeeShares: ZERO,
+			};
+		}
+		const now = new BN(Date.now() / 1000);
+		const sinceLast = now.sub(accountData.lastFeeUpdateTs);
+
+		let managementFeeAmount = depositorsEquity
+			.mul(accountData.managementFee)
+			.div(PERCENTAGE_PRECISION)
+			.mul(sinceLast)
+			.div(ONE_YEAR);
+		managementFeeAmount = BN.min(
+			managementFeeAmount,
+			depositorsEquity.sub(ONE)
+		);
+
+		const newTotalSharesFactor = depositorsEquity
+			.mul(PERCENTAGE_PRECISION)
+			.div(depositorsEquity.sub(managementFeeAmount));
+		let newTotalShares = accountData.totalShares
+			.mul(newTotalSharesFactor)
+			.div(PERCENTAGE_PRECISION);
+		newTotalShares = BN.max(newTotalShares, accountData.userShares);
+
+		const managementFeeShares = newTotalShares.sub(accountData.totalShares);
+
+		return { totalShares: newTotalShares, managementFeeShares };
+	}
+
+	calcSharesAfterManagementAndProtocolFee(
+		vaultEquity: BN,
+		vaultProtocol: VaultProtocol
+	): {
+		totalShares: BN;
+		managementFeeShares: BN;
+		protocolFeeShares: BN;
+	} {
+		const accountData = this.accountSubscriber.getAccountAndSlot().data;
+
+		if (!accountData.vaultProtocol) {
+			throw new Error('VaultProtocol does not exist for vault');
+		}
+
+		const depositorsEquity = accountData.userShares
+			.mul(vaultEquity)
+			.div(accountData.totalShares);
+
+		const now = new BN(Date.now() / 1000);
+		const sinceLast = now.sub(accountData.lastFeeUpdateTs);
+
+		if (
+			!accountData.managementFee.eq(ZERO) &&
+			!vaultProtocol.protocolFee.eq(ZERO) &&
+			depositorsEquity.gt(ZERO)
+		) {
+			const totalFee = accountData.managementFee.add(vaultProtocol.protocolFee);
+			const totalFeePayment = depositorsEquity
+				.mul(totalFee)
+				.div(PERCENTAGE_PRECISION)
+				.mul(sinceLast)
+				.div(ONE_YEAR);
+			const managementFeePayment = depositorsEquity
+				.mul(accountData.managementFee)
+				.div(PERCENTAGE_PRECISION)
+				.mul(sinceLast)
+				.div(ONE_YEAR);
+			const protocolFeePayment = BN.min(
+				totalFeePayment,
+				depositorsEquity.sub(new BN(1))
+			)
+				.mul(vaultProtocol.protocolFee)
+				.div(totalFee);
+
+			const newTotalSharesFactor = depositorsEquity
+				.mul(PERCENTAGE_PRECISION)
+				.div(
+					depositorsEquity.sub(managementFeePayment).sub(protocolFeePayment)
+				);
+			const newTotalShares = BN.max(
+				accountData.totalShares
+					.mul(newTotalSharesFactor)
+					.div(PERCENTAGE_PRECISION),
+				accountData.userShares
+			);
+
+			if (
+				(managementFeePayment.eq(ZERO) && protocolFeePayment.eq(ZERO)) ||
+				accountData.totalShares.eq(newTotalShares)
+			) {
+				return {
+					totalShares: accountData.totalShares,
+					managementFeeShares: ZERO,
+					protocolFeeShares: ZERO,
+				};
+			}
+
+			const managementFeeShares = newTotalShares.sub(accountData.totalShares);
+			const protocolFeeShares = newTotalShares.sub(accountData.totalShares);
+
+			return {
+				totalShares: newTotalShares,
+				managementFeeShares,
+				protocolFeeShares,
+			};
+		} else if (
+			accountData.managementFee.eq(ZERO) &&
+			!vaultProtocol.protocolFee.eq(ZERO) &&
+			depositorsEquity.gt(ZERO)
+		) {
+			const protocolFeePayment = depositorsEquity
+				.mul(vaultProtocol.protocolFee)
+				.div(PERCENTAGE_PRECISION)
+				.mul(sinceLast)
+				.div(ONE_YEAR);
+
+			const newTotalSharesFactor = depositorsEquity
+				.mul(PERCENTAGE_PRECISION)
+				.div(depositorsEquity.sub(protocolFeePayment));
+			const newTotalShares = BN.max(
+				accountData.totalShares
+					.mul(newTotalSharesFactor)
+					.div(PERCENTAGE_PRECISION),
+				accountData.userShares
+			);
+
+			if (
+				protocolFeePayment.eq(ZERO) ||
+				accountData.totalShares.eq(newTotalShares)
+			) {
+				return {
+					totalShares: accountData.totalShares,
+					managementFeeShares: ZERO,
+					protocolFeeShares: ZERO,
+				};
+			}
+
+			const protocolFeeShares = newTotalShares.sub(accountData.totalShares);
+			return {
+				totalShares: newTotalShares,
+				managementFeeShares: ZERO,
+				protocolFeeShares,
+			};
+		} else if (
+			!accountData.managementFee.eq(ZERO) &&
+			vaultProtocol.protocolFee.eq(ZERO) &&
+			depositorsEquity.gt(ZERO)
+		) {
+			const managementFeePayment = BN.min(
+				depositorsEquity
+					.mul(accountData.managementFee)
+					.div(PERCENTAGE_PRECISION)
+					.mul(sinceLast)
+					.div(ONE_YEAR),
+				depositorsEquity.sub(ONE)
+			);
+			const newTotalSharesFactor = depositorsEquity
+				.mul(PERCENTAGE_PRECISION)
+				.div(depositorsEquity.sub(managementFeePayment));
+			const newTotalShares = BN.max(
+				accountData.totalShares
+					.mul(newTotalSharesFactor)
+					.div(PERCENTAGE_PRECISION),
+				accountData.userShares
+			);
+
+			if (
+				managementFeePayment.eq(ZERO) ||
+				accountData.totalShares.eq(newTotalShares)
+			) {
+				return {
+					totalShares: accountData.totalShares,
+					managementFeeShares: ZERO,
+					protocolFeeShares: ZERO,
+				};
+			}
+
+			const managementFeeShares = newTotalShares.sub(accountData.totalShares);
+			return {
+				totalShares: newTotalShares,
+				managementFeeShares,
+				protocolFeeShares: ZERO,
+			};
+		} else {
+			return {
+				totalShares: accountData.totalShares,
+				managementFeeShares: ZERO,
+				protocolFeeShares: ZERO,
+			};
+		}
+	}
+}

package/src/accounts/vaultDepositorAccount.ts

@@ -0,0 +1,77 @@
+import { Program } from '@coral-xyz/anchor';
+import {
+	BN,
+	BulkAccountLoader,
+	PERCENTAGE_PRECISION,
+	ZERO,
+} from '@velocity-exchange/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { DriftVaults } from '../types/drift_vaults';
+import { VaultDepositor, VaultDepositorAccountEvents } from '../types/types';
+import { PollingVaultDepositorSubscriber } from '../accountSubscribers';
+import { VaultsProgramAccount } from './vaultsProgramAccount';
+import { getVaultDepositorAddressSync } from '../addresses';
+
+export class VaultDepositorAccount extends VaultsProgramAccount<
+	VaultDepositor,
+	VaultDepositorAccountEvents
+> {
+	constructor(
+		program: Program<DriftVaults>,
+		vaultDepositorPubkey: PublicKey,
+		accountLoader: BulkAccountLoader,
+		accountSubscriptionType: 'polling' | 'websocket' = 'polling'
+	) {
+		super();
+
+		if (accountSubscriptionType === 'polling') {
+			this.accountSubscriber = new PollingVaultDepositorSubscriber(
+				program,
+				vaultDepositorPubkey,
+				accountLoader
+			);
+		} else {
+			throw new Error('Websocket subscription not yet implemented');
+		}
+	}
+
+	static getAddressSync(
+		programId: PublicKey,
+		vault: PublicKey,
+		authority: PublicKey
+	): PublicKey {
+		return getVaultDepositorAddressSync(programId, vault, authority);
+	}
+
+	/**
+	 * Calculates the percentage of a depositor's equity that will be paid as profit share fees.
+	 *
+	 * @param vaultProfitShare Vault's profit share fee
+	 * @param depositorEquity Vault depositor's equity amount
+	 */
+	calcProfitShareFeesPct(vaultProfitShare: BN, depositorEquity: BN): BN {
+		const accountData = this.accountSubscriber.getAccountAndSlot().data;
+
+		const profit = depositorEquity
+			.sub(accountData.netDeposits)
+			.sub(accountData.cumulativeProfitShareAmount);
+
+		if (profit.lte(new BN(0)) || depositorEquity.isZero()) {
+			return ZERO;
+		}
+
+		const profitShareAmount = profit
+			.mul(vaultProfitShare)
+			.div(PERCENTAGE_PRECISION);
+
+		if (depositorEquity.eq(new BN(0))) {
+			return ZERO;
+		}
+
+		const profitShareProportion = profitShareAmount
+			.mul(PERCENTAGE_PRECISION)
+			.div(depositorEquity);
+
+		return profitShareProportion;
+	}
+}

package/src/accounts/vaultsProgramAccount.ts

@@ -0,0 +1,38 @@
+import EventEmitter from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import {
+	VaultsProgramAccountBaseEvents,
+	VaultsProgramAccountSubscriber,
+} from '../types/types';
+
+export abstract class VaultsProgramAccount<
+	Account,
+	AccountEvents extends VaultsProgramAccountBaseEvents
+> {
+	// @ts-ignore
+	accountSubscriber: VaultsProgramAccountSubscriber<Account, AccountEvents>;
+
+	get isSubscribed(): boolean {
+		return this.accountSubscriber.isSubscribed;
+	}
+
+	get eventEmitter(): StrictEventEmitter<EventEmitter, AccountEvents> {
+		return this.accountSubscriber.eventEmitter;
+	}
+
+	async subscribe(): Promise<boolean> {
+		return await this.accountSubscriber.subscribe();
+	}
+
+	async unsubscribe(): Promise<void> {
+		return await this.accountSubscriber.unsubscribe();
+	}
+
+	getData(): Account {
+		return this.accountSubscriber.getAccountAndSlot()?.data;
+	}
+
+	async updateData(newData: Account, slot: number): Promise<void> {
+		return await this.accountSubscriber.updateData(newData, slot);
+	}
+}