@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/math/orders.ts

@@ -1,378 +0,0 @@
-import {
-	isOneOfVariant,
-	isVariant,
-	PerpMarketAccount,
-	AMM,
-	MarketStats,
-	Order,
-	PositionDirection,
-	MarketTypeStr,
-	OrderBitFlag,
-	StateAccount,
-} from '../types';
-import {
-	ZERO,
-	ONE,
-	SPOT_MARKET_IMF_PRECISION,
-	MARGIN_PRECISION,
-} from '../constants/numericConstants';
-import { BN } from '../isomorphic/anchor';
-import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
-import {
-	getAuctionPrice,
-	isAuctionComplete,
-	isFallbackAvailableLiquiditySource,
-} from './auction';
-import {
-	calculateMaxBaseAssetAmountFillable,
-	calculateMaxBaseAssetAmountToTrade,
-	calculateUpdatedAMM,
-} from './amm';
-import { calculateSizePremiumLiabilityWeight } from './margin';
-
-export function standardizeBaseAssetAmount(
-	baseAssetAmount: BN,
-	stepSize: BN
-): BN {
-	const remainder = baseAssetAmount.mod(stepSize);
-	return baseAssetAmount.sub(remainder);
-}
-
-export function standardizePrice(
-	price: BN,
-	tickSize: BN,
-	direction: PositionDirection
-): BN {
-	if (price.eq(ZERO)) {
-		console.log('price is zero');
-		return price;
-	}
-
-	const remainder = price.mod(tickSize);
-	if (remainder.eq(ZERO)) {
-		return price;
-	}
-
-	if (isVariant(direction, 'long')) {
-		return price.sub(remainder);
-	} else {
-		return price.add(tickSize).sub(remainder);
-	}
-}
-
-export function getLimitPrice<T extends MarketTypeStr>(
-	order: Order,
-	oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData,
-	slot: number,
-	fallbackPrice?: BN
-): BN | undefined {
-	if (hasAuctionPrice(order, slot)) {
-		return getAuctionPrice(order, slot, oraclePriceData.price);
-	} else if (!order.oraclePriceOffset.eq(ZERO)) {
-		return BN.max(oraclePriceData.price.add(order.oraclePriceOffset), ONE);
-	} else if (order.price.eq(ZERO)) {
-		return fallbackPrice;
-	} else {
-		return order.price;
-	}
-}
-
-export function hasLimitPrice(order: Order, slot: number): boolean {
-	return (
-		order.price.gt(ZERO) ||
-		!order.oraclePriceOffset.eq(ZERO) ||
-		!isAuctionComplete(order, slot)
-	);
-}
-
-export function hasAuctionPrice(order: Order, slot: number): boolean {
-	return (
-		!isAuctionComplete(order, slot) &&
-		(!order.auctionStartPrice.eq(ZERO) || !order.auctionEndPrice.eq(ZERO))
-	);
-}
-
-export function isFillableByVAMM(
-	order: Order,
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
-	slot: number,
-	ts: number,
-	state: StateAccount
-): boolean {
-	return (
-		(isFallbackAvailableLiquiditySource(
-			order,
-			mmOraclePriceData,
-			slot,
-			state,
-			market
-		) &&
-			calculateBaseAssetAmountForAmmToFulfill(
-				order,
-				market,
-				mmOraclePriceData,
-				slot
-			).gt(ZERO)) ||
-		isOrderExpired(order, ts)
-	);
-}
-
-export function isLowRiskForAmm(
-	order: Order,
-	mmOraclePriceData: MMOraclePriceData,
-	isLiquidation?: boolean
-): boolean {
-	if (isVariant(order.marketType, 'spot')) {
-		return false;
-	}
-
-	const orderOlderThanOracleDelay = new BN(order.slot).lte(
-		mmOraclePriceData.slot
-	);
-
-	return (
-		orderOlderThanOracleDelay ||
-		isLiquidation ||
-		(order.bitFlags & OrderBitFlag.SafeTriggerOrder) !== 0
-	);
-}
-
-export function calculateBaseAssetAmountForAmmToFulfill(
-	order: Order,
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
-	slot: number
-): BN {
-	if (mustBeTriggered(order) && !isTriggered(order)) {
-		return ZERO;
-	}
-
-	const limitPrice = getLimitPrice(order, mmOraclePriceData, slot);
-	let baseAssetAmount;
-
-	const updatedAMM = calculateUpdatedAMM(market.amm, mmOraclePriceData);
-	if (limitPrice !== undefined) {
-		baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
-			order,
-			updatedAMM,
-			market.marketStats,
-			market.orderStepSize,
-			market.orderTickSize,
-			limitPrice,
-			mmOraclePriceData
-		);
-	} else {
-		baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
-	}
-
-	const maxBaseAssetAmount = calculateMaxBaseAssetAmountFillable(
-		updatedAMM,
-		market.orderStepSize,
-		order.direction
-	);
-
-	return BN.min(maxBaseAssetAmount, baseAssetAmount);
-}
-
-export function calculateBaseAssetAmountToFillUpToLimitPrice(
-	order: Order,
-	amm: AMM,
-	marketStats: MarketStats,
-	orderStepSize: BN,
-	orderTickSize: BN,
-	limitPrice: BN,
-	mmOraclePriceData: MMOraclePriceData
-): BN {
-	const adjustedLimitPrice = isVariant(order.direction, 'long')
-		? limitPrice.sub(orderTickSize)
-		: limitPrice.add(orderTickSize);
-
-	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
-		amm,
-		marketStats,
-		adjustedLimitPrice,
-		order.direction,
-		mmOraclePriceData
-	);
-
-	const baseAssetAmount = standardizeBaseAssetAmount(
-		maxAmountToTrade,
-		orderStepSize
-	);
-
-	// Check that directions are the same
-	const sameDirection = isSameDirection(direction, order.direction);
-	if (!sameDirection) {
-		return ZERO;
-	}
-
-	const baseAssetAmountUnfilled = order.baseAssetAmount.sub(
-		order.baseAssetAmountFilled
-	);
-	return baseAssetAmount.gt(baseAssetAmountUnfilled)
-		? baseAssetAmountUnfilled
-		: baseAssetAmount;
-}
-
-function isSameDirection(
-	firstDirection: PositionDirection,
-	secondDirection: PositionDirection
-): boolean {
-	return (
-		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
-		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
-	);
-}
-
-export function isOrderExpired(
-	order: Order,
-	ts: number,
-	enforceBuffer = false,
-	bufferSeconds = 15
-): boolean {
-	if (
-		mustBeTriggered(order) ||
-		!isVariant(order.status, 'open') ||
-		order.maxTs.eq(ZERO)
-	) {
-		return false;
-	}
-
-	let maxTs;
-	if (enforceBuffer && isLimitOrder(order)) {
-		maxTs = order.maxTs.addn(bufferSeconds);
-	} else {
-		maxTs = order.maxTs;
-	}
-
-	return new BN(ts).gt(maxTs);
-}
-
-export function isMarketOrder(order: Order): boolean {
-	return isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle']);
-}
-
-export function isLimitOrder(order: Order): boolean {
-	return isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
-}
-
-export function mustBeTriggered(order: Order): boolean {
-	return isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']);
-}
-
-export function isTriggered(order: Order): boolean {
-	return isOneOfVariant(order.triggerCondition, [
-		'triggeredAbove',
-		'triggeredBelow',
-	]);
-}
-
-export function isRestingLimitOrder(order: Order, slot: number): boolean {
-	if (!isLimitOrder(order)) {
-		return false;
-	}
-
-	return order.postOnly || isAuctionComplete(order, slot);
-}
-
-const FLAG_IS_SIGNED_MSG = 0x01;
-export function isSignedMsgOrder(order: Order): boolean {
-	return (order.bitFlags & FLAG_IS_SIGNED_MSG) !== 0;
-}
-
-const FLAG_HAS_BUILDER = 0x10;
-export function hasBuilder(order: Order): boolean {
-	return (order.bitFlags & FLAG_HAS_BUILDER) !== 0;
-}
-
-export function calculateOrderBaseAssetAmount(
-	order: Order,
-	existingBaseAssetAmount: BN
-): BN {
-	if (!order.reduceOnly) {
-		return order.baseAssetAmount;
-	}
-
-	if (isVariant(order.direction, 'long')) {
-		return BN.min(
-			BN.min(existingBaseAssetAmount, ZERO).abs(),
-			order.baseAssetAmount
-		);
-	} else {
-		return BN.min(BN.max(existingBaseAssetAmount, ZERO), order.baseAssetAmount);
-	}
-}
-
-// ---------- inverse ----------
-/**
- * Invert the size-premium liability weight: given a target margin ratio (liability weight),
- * return the max `size` (AMM_RESERVE_PRECISION units) that still yields <= target.
- *
- * Returns:
- * - BN size (>=0) if bounded
- * - null if impossible (target < liabilityWeight) OR imfFactor == 0 (unbounded)
- *
- * Note: a market.maxOpenInterest of 0 means "no configured cap" and is treated
- * as unlimited rather than a hard cap of 0.
- */
-export function maxSizeForTargetLiabilityWeightBN(
-	target: BN,
-	imfFactor: BN,
-	liabilityWeight: BN,
-	market: PerpMarketAccount
-): BN | null {
-	if (target.lt(liabilityWeight)) return null;
-	if (imfFactor.isZero()) return null;
-
-	const base = liabilityWeight.muln(4).divn(5);
-
-	const denom = new BN(100_000)
-		.mul(SPOT_MARKET_IMF_PRECISION)
-		.div(MARGIN_PRECISION);
-	if (denom.isZero())
-		throw new Error('denom=0: bad precision/spotImfPrecision');
-
-	const allowedInc = target.gt(base) ? target.sub(base) : ZERO;
-
-	const maxSqrt = allowedInc.mul(denom).div(imfFactor);
-
-	if (maxSqrt.lte(ZERO)) {
-		const fitsZero = calculateSizePremiumLiabilityWeight(
-			ZERO,
-			imfFactor,
-			liabilityWeight,
-			MARGIN_PRECISION
-		).lte(target);
-		return fitsZero ? ZERO : null;
-	}
-
-	let hi = maxSqrt.mul(maxSqrt).sub(ONE).divn(10);
-	if (hi.isNeg()) hi = ZERO;
-
-	let lo = ZERO;
-	while (lo.lt(hi)) {
-		const mid = lo.add(hi).add(ONE).divn(2); // upper mid to prevent infinite loop
-		if (
-			calculateSizePremiumLiabilityWeight(
-				mid,
-				imfFactor,
-				liabilityWeight,
-				MARGIN_PRECISION
-			).lte(target)
-		) {
-			lo = mid;
-		} else {
-			hi = mid.sub(ONE);
-		}
-	}
-
-	// cap at max OI. A maxOpenInterest of 0 means no configured cap (unlimited),
-	// matching the on-chain convention — do not treat it as a hard cap of 0.
-	const maxOpenInterest = market.maxOpenInterest;
-	if (!maxOpenInterest.isZero() && lo.gt(maxOpenInterest)) {
-		return maxOpenInterest;
-	}
-
-	return lo;
-}

package/src/math/position.ts

@@ -1,334 +0,0 @@
-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,
-					market.marketStats,
-					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);
-
-		default:
-			throw new Error('Invalid position direction to close');
-	}
-}
-
-/**
- * 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.cumulativeFundingRateLong;
-	} else {
-		ammCumulativeFundingRate = market.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;
-}
-
-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)
-	);
-}