@drift-labs/vaults-sdk 0.1.0

package/src/accountSubscribers/pollingVaultSubscriber.ts

@@ -0,0 +1,62 @@
+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 { buffer, slot } = this.accountLoader.getBufferAndSlot(this.pubkey);
+		const currentSlot = this.account?.slot ?? 0;
+		if (buffer && slot > currentSlot) {
+			const account = this.program.account.vault.coder.accounts.decode(
+				'vault',
+				buffer
+			);
+			this.account = { data: account, 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,111 @@
+import {
+	BulkAccountLoader,
+	DataAndSlot,
+	NotSubscribedError,
+	PublicKey,
+} from '@drift-labs/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 = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		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();
+		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,86 @@
+import { BN, Program } from '@coral-xyz/anchor';
+import {
+	BulkAccountLoader,
+	ONE,
+	ONE_YEAR,
+	PERCENTAGE_PRECISION,
+	ZERO,
+} from '@drift-labs/sdk';
+import { PublicKey } from '@solana/web3.js';
+import { DriftVaults } from '../types/drift_vaults';
+import { Vault, VaultAccountEvents } 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));
+	}
+
+	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 };
+	}
+}

package/src/accounts/vaultDepositorAccount.ts

@@ -0,0 +1,67 @@
+import { BN, Program } from '@coral-xyz/anchor';
+import { BulkAccountLoader, PERCENTAGE_PRECISION, ZERO } from '@drift-labs/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))) {
+			return ZERO;
+		}
+
+		const profitShareAmount = profit
+			.mul(vaultProfitShare)
+			.div(PERCENTAGE_PRECISION);
+		const profitShareProportion = profitShareAmount
+			.mul(PERCENTAGE_PRECISION)
+			.div(depositorEquity);
+
+		return profitShareProportion;
+	}
+}

package/src/accounts/vaultsProgramAccount.ts

@@ -0,0 +1,37 @@
+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
+> {
+	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);
+	}
+}

package/src/addresses.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from '@solana/web3.js';
+import * as anchor from '@coral-xyz/anchor';
+
+export function getVaultAddressSync(
+	programId: PublicKey,
+	encodedName: number[]
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('vault')),
+			Buffer.from(encodedName),
+		],
+		programId
+	)[0];
+}
+
+export function getVaultDepositorAddressSync(
+	programId: PublicKey,
+	vault: PublicKey,
+	authority: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('vault_depositor')),
+			vault.toBuffer(),
+			authority.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
+export function getTokenVaultAddressSync(
+	programId: PublicKey,
+	vault: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('vault_token_account')),
+			vault.toBuffer(),
+		],
+		programId
+	)[0];
+}

package/src/constants/index.ts

@@ -0,0 +1,3 @@
+import { BN } from '@drift-labs/sdk';
+
+export const VAULT_SHARES_PRECISION_EXP = new BN(6);