@velocity-exchange/vaults-sdk 0.0.1

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './addresses';
+export * from './name';
+export * from './vaultClient';
+export * from './accounts';
+export * from './accountSubscribers';
+export * from './utils';
+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,2 @@
+export * from './vaultDepositor';
+export * from './vault';

package/src/math/vault.ts

@@ -0,0 +1,71 @@
+import { BN, BigNum } from '@velocity-exchange/sdk';
+
+const DEFAULT_MODIFIED_DIETZ_RESULT = {
+	apy: 0,
+	returns: 0,
+};
+
+/**
+ * https://en.wikipedia.org/wiki/Modified_Dietz_method
+ * @param currentVaultEquityBaseValue
+ * @param vaultDeposits
+ * @returns weighted APY and cumulative returns calculated using the Modified Dietz method
+ */
+export const calcModifiedDietz = (
+	currentVaultEquityBaseValue: BigNum,
+	precisionExp: BN,
+	vaultDeposits: {
+		ts: string;
+		marketIndex: number;
+		amount: string;
+		direction: 'deposit' | 'withdraw';
+	}[],
+	startingMarketValue = 0
+): { apy: number; returns: number } => {
+	if (vaultDeposits.length === 0) {
+		return DEFAULT_MODIFIED_DIETZ_RESULT;
+	}
+
+	const endingMarkeValue = currentVaultEquityBaseValue.toNum();
+	const firstDepositTs = parseInt(vaultDeposits[vaultDeposits.length - 1].ts);
+	const lastDepositTs = parseInt(vaultDeposits[0].ts);
+	const nowTs = Date.now() / 1000;
+	if (nowTs < firstDepositTs) {
+		console.error('nowTs < firstDepositTs');
+		return DEFAULT_MODIFIED_DIETZ_RESULT;
+	}
+	if (lastDepositTs < firstDepositTs) {
+		console.error('lastDepositTs < firstDepositTs');
+		return DEFAULT_MODIFIED_DIETZ_RESULT;
+	}
+	const totalDuration = nowTs - firstDepositTs;
+
+	let totalNetFlow = 0;
+	let weightedNetFlow = 0;
+	vaultDeposits.forEach((deposit) => {
+		let depositAmount = BigNum.from(deposit.amount, precisionExp).toNum();
+		if (deposit.direction === 'withdraw') {
+			depositAmount *= -1;
+		}
+		totalNetFlow += depositAmount;
+		const depositAge = parseInt(deposit.ts) - firstDepositTs;
+		const depositWeight = (totalDuration - depositAge) / totalDuration;
+		if (depositWeight < 0) {
+			console.error('depositWeight < 0');
+			return -1;
+		}
+		weightedNetFlow += depositWeight * depositAmount;
+	}, 0);
+
+	const modifiedDietzReturns =
+		(endingMarkeValue - startingMarketValue - totalNetFlow) /
+		(startingMarketValue + weightedNetFlow);
+
+	if (modifiedDietzReturns < 0) return DEFAULT_MODIFIED_DIETZ_RESULT;
+
+	const annualized =
+		Math.pow(1 + modifiedDietzReturns, (86400 * 365) / totalDuration) - 1;
+
+	const positiveApy = Math.max(annualized, 0);
+	return { apy: positiveApy, returns: modifiedDietzReturns };
+};

package/src/math/vaultDepositor.ts

@@ -0,0 +1,90 @@
+import {
+	BN,
+	PERCENTAGE_PRECISION,
+	ZERO,
+	unstakeSharesToAmount as depositSharesToVaultAmount,
+	stakeAmountToShares as vaultAmountToDepositorShares,
+} from '@velocity-exchange/sdk';
+import { Vault, VaultDepositor, VaultProtocol } 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,
+	vaultProtocol?: VaultProtocol
+) {
+	const profit = totalAmount.sub(
+		vaultDepositor.netDeposits.add(vaultDepositor.cumulativeProfitShareAmount)
+	);
+	let profitShare = vault.profitShare;
+	if (vaultProtocol) {
+		profitShare += vaultProtocol.protocolProfitShare;
+	}
+	if (profit.gt(ZERO)) {
+		const profitShareAmount = profit
+			.mul(new BN(profitShare))
+			.div(PERCENTAGE_PRECISION);
+		return profitShareAmount;
+	}
+	return ZERO;
+}
+
+/**
+ * Calculates the equity across deposits and realized profit for a vaultDepositor
+ * @param vaultDepositor vault depositor account
+ * @param vaultEquity total vault equity
+ * @param vault vault account
+ * @param vaultProtocol if vault account has "vaultProtocol" then this is needed
+ * @returns
+ */
+export function calculateRealizedVaultDepositorEquity(
+	vaultDepositor: VaultDepositor,
+	vaultEquity: BN,
+	vault: Vault,
+	vaultProtocol?: VaultProtocol
+): BN {
+	const vdAmount = depositSharesToVaultAmount(
+		vaultDepositor.vaultShares,
+		vault.totalShares,
+		vaultEquity
+	);
+	const profitShareAmount = calculateProfitShare(
+		vaultDepositor,
+		vdAmount,
+		vault,
+		vaultProtocol
+	);
+	return vdAmount.sub(profitShareAmount);
+}

package/src/name.ts

@@ -0,0 +1,18 @@
+export const MAX_NAME_LENGTH = 32;
+
+export function encodeName(name: string): number[] {
+	if (name.length > MAX_NAME_LENGTH) {
+		throw Error(`Name (${name}) longer than 32 characters`);
+	}
+
+	const buffer = Buffer.alloc(32);
+	buffer.fill(name);
+	buffer.fill(' ', name.length);
+
+	return Array(...buffer);
+}
+
+export function decodeName(bytes: number[]): string {
+	const buffer = Buffer.from(bytes);
+	return buffer.toString('utf8').trim();
+}

package/src/parsers/index.ts

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

package/src/parsers/logParser.ts

@@ -0,0 +1,28 @@
+import { Program } from '@coral-xyz/anchor';
+import { TransactionSignature } from '@solana/web3.js';
+import { WrappedEvents } from '../types/types';
+
+type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
+
+export class LogParser {
+	constructor(private program: Program) {}
+
+	public parseEventsFromLogs(event: Log): WrappedEvents {
+		const records: WrappedEvents = [];
+
+		// @ts-ignore
+		const eventGenerator = this.program._events._eventParser.parseLogs(
+			event.logs,
+			false
+		);
+
+		for (const eventLog of eventGenerator) {
+			eventLog.data.txSig = event.txSig;
+			eventLog.data.slot = event.slot;
+			eventLog.data.eventType = eventLog.name;
+			records.push(eventLog.data);
+		}
+
+		return records;
+	}
+}