@velocity-exchange/sdk 0.0.1

package/src/math/position.ts

@@ -0,0 +1,340 @@
+import { BN } from '../isomorphic/anchor';
+import {
+	AMM_RESERVE_PRECISION,
+	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	FUNDING_RATE_BUFFER_PRECISION,
+	PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+import {
+	PerpMarketAccount,
+	PositionDirection,
+	PerpPosition,
+	SpotMarketAccount,
+	PositionFlag,
+} from '../types';
+import {
+	calculateUpdatedAMM,
+	calculateUpdatedAMMSpreadReserves,
+	calculateAmmReservesAfterSwap,
+	getSwapDirection,
+} from './amm';
+import { calculateBaseAssetValueWithOracle } from './margin';
+import { calculateNetUserPnlImbalance } from './market';
+
+/**
+ * calculateBaseAssetValue
+ * = market value of closing entire position
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+export function calculateBaseAssetValue(
+	market: PerpMarketAccount,
+	userPosition: PerpPosition,
+	mmOraclePriceData: MMOraclePriceData,
+	useSpread = true,
+	skipUpdate = false,
+	latestSlot?: BN
+): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const directionToClose = findDirectionToClose(userPosition);
+	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+
+	if (!skipUpdate) {
+		if (market.amm.baseSpread > 0 && useSpread) {
+			const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+				calculateUpdatedAMMSpreadReserves(
+					market.amm,
+					directionToClose,
+					mmOraclePriceData,
+					latestSlot
+				);
+			prepegAmm = {
+				baseAssetReserve,
+				quoteAssetReserve,
+				sqrtK: sqrtK,
+				pegMultiplier: newPeg,
+			};
+		} else {
+			prepegAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
+		}
+	} else {
+		prepegAmm = market.amm;
+	}
+
+	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
+		prepegAmm,
+		'base',
+		userPosition.baseAssetAmount.abs(),
+		getSwapDirection('base', directionToClose)
+	);
+
+	switch (directionToClose) {
+		case PositionDirection.SHORT:
+			return prepegAmm.quoteAssetReserve
+				.sub(newQuoteAssetReserve)
+				.mul(prepegAmm.pegMultiplier)
+				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+
+		case PositionDirection.LONG:
+			return newQuoteAssetReserve
+				.sub(prepegAmm.quoteAssetReserve)
+				.mul(prepegAmm.pegMultiplier)
+				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+				.add(ONE);
+	}
+}
+
+/**
+ * calculatePositionPNL
+ * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
+ * @param market
+ * @param PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+export function calculatePositionPNL(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
+	withFunding = false,
+	oraclePriceData: Pick<OraclePriceData, 'price'>
+): BN {
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
+		return perpPosition.quoteAssetAmount;
+	}
+
+	const baseAssetValue = calculateBaseAssetValueWithOracle(
+		market,
+		perpPosition,
+		oraclePriceData
+	);
+
+	const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+		? new BN(-1)
+		: new BN(1);
+	let pnl = baseAssetValue
+		.mul(baseAssetValueSign)
+		.add(perpPosition.quoteAssetAmount);
+
+	if (withFunding) {
+		const fundingRatePnL = calculateUnsettledFundingPnl(market, perpPosition);
+		pnl = pnl.add(fundingRatePnL);
+	}
+
+	return pnl;
+}
+
+export function calculateClaimablePnl(
+	market: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
+	perpPosition: PerpPosition,
+	oraclePriceData: Pick<OraclePriceData, 'price'>
+): BN {
+	const unrealizedPnl = calculatePositionPNL(
+		market,
+		perpPosition,
+		true,
+		oraclePriceData
+	);
+
+	let unsettledPnl = unrealizedPnl;
+	if (unrealizedPnl.gt(ZERO)) {
+		const excessPnlPool = BN.max(
+			ZERO,
+			calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(
+				new BN(-1)
+			)
+		);
+
+		const maxPositivePnl = BN.max(
+			perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount),
+			ZERO
+		).add(excessPnlPool);
+
+		unsettledPnl = BN.min(maxPositivePnl, unrealizedPnl);
+	}
+	return unsettledPnl;
+}
+
+/**
+ * Returns total fees and funding pnl for a position
+ *
+ * @param market
+ * @param PerpPosition
+ * @param includeUnsettled include unsettled funding in return value (default: true)
+ * @returns — // QUOTE_PRECISION
+ */
+export function calculateFeesAndFundingPnl(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
+	includeUnsettled = true
+): BN {
+	const settledFundingAndFeesPnl = perpPosition.quoteBreakEvenAmount.sub(
+		perpPosition.quoteEntryAmount
+	);
+
+	if (!includeUnsettled) {
+		return settledFundingAndFeesPnl;
+	}
+
+	const unsettledFundingPnl = calculateUnsettledFundingPnl(
+		market,
+		perpPosition
+	);
+
+	return settledFundingAndFeesPnl.add(unsettledFundingPnl);
+}
+
+/**
+ * Returns unsettled funding pnl for the position
+ *
+ * To calculate all fees and funding pnl including settled, use calculateFeesAndFundingPnl
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+export function calculateUnsettledFundingPnl(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition
+): BN {
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	let ammCumulativeFundingRate: BN;
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
+		ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+	} else {
+		ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+	}
+
+	const perPositionFundingRate = ammCumulativeFundingRate
+		.sub(perpPosition.lastCumulativeFundingRate)
+		.mul(perpPosition.baseAssetAmount)
+		.div(AMM_RESERVE_PRECISION)
+		.div(FUNDING_RATE_BUFFER_PRECISION)
+		.mul(new BN(-1));
+
+	return perPositionFundingRate;
+}
+
+/**
+ * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
+ */
+export function calculatePositionFundingPNL(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition
+): BN {
+	return calculateUnsettledFundingPnl(market, perpPosition);
+}
+
+export function positionIsAvailable(position: PerpPosition): boolean {
+	return (
+		position.baseAssetAmount.eq(ZERO) &&
+		position.openOrders === 0 &&
+		position.quoteAssetAmount.eq(ZERO) &&
+		position.isolatedPositionScaledBalance.eq(ZERO) &&
+		!positionIsBeingLiquidated(position)
+	);
+}
+
+export function positionIsBeingLiquidated(position: PerpPosition): boolean {
+	return (
+		(position.positionFlag &
+			(PositionFlag.BeingLiquidated | PositionFlag.Bankruptcy)) >
+		0
+	);
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export function calculateBreakEvenPrice(userPosition: PerpPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteBreakEvenAmount
+		.mul(PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export function calculateEntryPrice(userPosition: PerpPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteEntryAmount
+		.mul(PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+export function calculateCostBasis(
+	userPosition: PerpPosition,
+	includeSettledPnl = false
+): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteAssetAmount
+		.add(includeSettledPnl ? userPosition.settledPnl : ZERO)
+		.mul(PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+export function findDirectionToClose(
+	userPosition: PerpPosition
+): PositionDirection {
+	return userPosition.baseAssetAmount.gt(ZERO)
+		? PositionDirection.SHORT
+		: PositionDirection.LONG;
+}
+
+export function positionCurrentDirection(
+	userPosition: PerpPosition
+): PositionDirection {
+	return userPosition.baseAssetAmount.gte(ZERO)
+		? PositionDirection.LONG
+		: PositionDirection.SHORT;
+}
+
+export function isEmptyPosition(userPosition: PerpPosition): boolean {
+	return userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders === 0;
+}
+
+export function hasOpenOrders(position: PerpPosition): boolean {
+	return (
+		position.openOrders != 0 ||
+		!position.openBids.eq(ZERO) ||
+		!position.openAsks.eq(ZERO)
+	);
+}

package/src/math/repeg.ts

@@ -0,0 +1,214 @@
+import { BN } from '../isomorphic/anchor';
+import { assert } from '../assert/assert';
+import {
+	PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	PEG_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	PRICE_DIV_PEG,
+	QUOTE_PRECISION,
+	ZERO,
+	ONE,
+	PERCENTAGE_PRECISION,
+} from '../constants/numericConstants';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	amm: AMM,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.baseAssetAmountWithAmm;
+	const Q = amm.pegMultiplier;
+
+	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+
+	const p = numerator.mul(PRICE_PRECISION).div(denomenator);
+
+	const cost = quoteScale
+		.mul(PERCENTAGE_PRECISION)
+		.mul(PERCENTAGE_PRECISION)
+		.div(x.add(d))
+		.sub(
+			quoteScale
+				.mul(p)
+				.mul(PERCENTAGE_PRECISION)
+				.mul(PERCENTAGE_PRECISION)
+				.div(PRICE_PRECISION)
+				.div(x.mul(p).div(PRICE_PRECISION).add(d))
+		)
+		.div(PERCENTAGE_PRECISION)
+		.div(PERCENTAGE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+
+	return cost.mul(new BN(-1));
+}
+
+// /**
+//  * Helper function calculating adjust k cost
+//  * @param amm
+//  * @param numerator
+//  * @param denomenator
+//  * @returns cost : Precision QUOTE_ASSET_PRECISION
+//  */
+// export function calculateAdjustKCost2(
+// 	amm: AMM,
+// 	numerator: BN,
+// 	denomenator: BN
+// ): BN {
+// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
+// 		? PositionDirection.SHORT
+// 		: PositionDirection.LONG;
+
+// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
+// 		calculateAmmReservesAfterSwap(
+// 			amm,
+// 			'base',
+// 			amm.baseAssetAmountWithAmm.abs(),
+// 			getSwapDirection('base', directionToClose)
+// 		);
+// }
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(amm: AMM, newPeg: BN): BN {
+	const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+	const cost = dqar
+		.mul(newPeg.sub(amm.pegMultiplier))
+		.div(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+	return cost;
+}
+
+export function calculateBudgetedKBN(
+	x: BN,
+	y: BN,
+	budget: BN,
+	Q: BN,
+	d: BN
+): [BN, BN] {
+	assert(Q.gt(new BN(0)));
+	const C = budget.mul(new BN(-1));
+
+	let dSign = new BN(1);
+	if (d.lt(new BN(0))) {
+		dSign = new BN(-1);
+	}
+	const pegged_y_d_d = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numer1 = pegged_y_d_d;
+	const numer2 = C.mul(d)
+		.div(QUOTE_PRECISION)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.mul(dSign);
+
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = pegged_y_d_d;
+
+	// protocol is spending to increase k
+	if (C.lt(ZERO)) {
+		// thus denom1 is negative and solution is unstable
+		if (denom1.abs().gt(denom2.abs())) {
+			console.log('denom1 > denom2', denom1.toString(), denom2.toString());
+			console.log('budget cost exceeds stable K solution');
+			return [new BN(10000), new BN(1)];
+		}
+	}
+
+	const numerator = numer1.sub(numer2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1.add(denom2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN] {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
+
+	// numer
+	//   =  y*d*d*Q - Cxd - Cdd
+	//   =  y/x*Q*d*d - Cd - Cd/x
+	//   = mark      - C/d - C/(x)
+	//   =  mark/C    - 1/d - 1/x
+
+	// denom
+	// = C*x*x + C*x*d + y*d*d*Q
+	// = x/d**2 + 1 / d + mark/C
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.baseAssetAmountWithAmm;
+	const Q = amm.pegMultiplier;
+
+	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(
+	amm: AMM,
+	budget: BN,
+	targetPrice: BN
+): BN {
+	let perPegCost = amm.quoteAssetReserve
+		.sub(amm.terminalQuoteAssetReserve)
+		.div(AMM_RESERVE_PRECISION.div(PRICE_PRECISION));
+
+	if (perPegCost.gt(ZERO)) {
+		perPegCost = perPegCost.add(ONE);
+	} else if (perPegCost.lt(ZERO)) {
+		perPegCost = perPegCost.sub(ONE);
+	}
+
+	const targetPeg = targetPrice
+		.mul(amm.baseAssetReserve)
+		.div(amm.quoteAssetReserve)
+		.div(PRICE_DIV_PEG);
+
+	const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
+
+	const useTargetPeg =
+		(perPegCost.lt(ZERO) && pegChangeDirection.gt(ZERO)) ||
+		(perPegCost.gt(ZERO) && pegChangeDirection.lt(ZERO));
+
+	if (perPegCost.eq(ZERO) || useTargetPeg) {
+		return targetPeg;
+	}
+
+	const budgetDeltaPeg = budget.mul(PEG_PRECISION).div(perPegCost);
+	const newPeg = BN.max(ONE, amm.pegMultiplier.add(budgetDeltaPeg));
+
+	return newPeg;
+}