@velocity-exchange/sdk 0.0.1

package/src/math/auction.ts

@@ -0,0 +1,374 @@
+import {
+	isOneOfVariant,
+	isVariant,
+	OracleValidity,
+	Order,
+	PerpOperation,
+	PositionDirection,
+	StateAccount,
+} from '../types';
+import { BN } from '../isomorphic/anchor';
+import {
+	ONE,
+	ZERO,
+	QUOTE_PRECISION,
+	PRICE_PRECISION,
+} from '../constants/numericConstants';
+import { getVariant, OrderBitFlag, PerpMarketAccount } from '../types';
+import { getPerpMarketTierNumber } from './tiers';
+import { MMOraclePriceData } from '../oracles/types';
+import { isLowRiskForAmm } from './orders';
+import { getOracleValidity } from './oracles';
+import { isOperationPaused } from './exchangeStatus';
+
+export function isAuctionComplete(order: Order, slot: number): boolean {
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
+}
+
+export function isFallbackAvailableLiquiditySource(
+	order: Order,
+	mmOraclePriceData: MMOraclePriceData,
+	slot: number,
+	state: StateAccount,
+	market: PerpMarketAccount,
+	isLiquidation?: boolean
+): boolean {
+	if (isOperationPaused(market.pausedOperations, PerpOperation.AMM_FILL)) {
+		return false;
+	}
+
+	// TODO: include too much drawdown check & mm oracle volatility
+
+	const oracleValidity = getOracleValidity(
+		market!,
+		{
+			price: mmOraclePriceData.price,
+			slot: mmOraclePriceData.slot,
+			confidence: mmOraclePriceData.confidence,
+			hasSufficientNumberOfDataPoints:
+				mmOraclePriceData.hasSufficientNumberOfDataPoints,
+		},
+		state.oracleGuardRails,
+		new BN(slot)
+	);
+	if (oracleValidity <= OracleValidity.StaleForAMMLowRisk) {
+		return false;
+	}
+
+	if (oracleValidity == OracleValidity.Valid) {
+		return true;
+	}
+
+	const isOrderLowRiskForAmm = isLowRiskForAmm(
+		order,
+		mmOraclePriceData,
+		isLiquidation
+	);
+
+	if (!isOrderLowRiskForAmm) {
+		return false;
+	} else {
+		return true;
+	}
+}
+
+/**
+ *
+ * @param order
+ * @param slot
+ * @param oraclePrice Use MMOraclePriceData source for perp orders, OraclePriceData for spot
+ * @returns BN
+ */
+export function getAuctionPrice(
+	order: Order,
+	slot: number,
+	oraclePrice: BN
+): BN {
+	if (
+		isOneOfVariant(order.orderType, ['market', 'triggerLimit']) ||
+		(isVariant(order.orderType, 'triggerMarket') &&
+			(order.bitFlags & OrderBitFlag.OracleTriggerMarket) === 0)
+	) {
+		return getAuctionPriceForFixedAuction(order, slot);
+	} else if (isVariant(order.orderType, 'limit')) {
+		if (order.oraclePriceOffset != null && order.oraclePriceOffset !== 0) {
+			return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+		} else {
+			return getAuctionPriceForFixedAuction(order, slot);
+		}
+	} else if (
+		isVariant(order.orderType, 'oracle') ||
+		(isVariant(order.orderType, 'triggerMarket') &&
+			(order.bitFlags & OrderBitFlag.OracleTriggerMarket) !== 0)
+	) {
+		return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+	} else {
+		throw Error(
+			`Cant get auction price for order type ${getVariant(order.orderType)}`
+		);
+	}
+}
+
+export function getAuctionPriceForFixedAuction(order: Order, slot: number): BN {
+	const slotsElapsed = new BN(slot).sub(order.slot);
+
+	const deltaDenominator = new BN(order.auctionDuration);
+	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
+
+	if (deltaDenominator.eq(ZERO)) {
+		return order.auctionEndPrice;
+	}
+
+	let priceDelta;
+	if (isVariant(order.direction, 'long')) {
+		priceDelta = order.auctionEndPrice
+			.sub(order.auctionStartPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	} else {
+		priceDelta = order.auctionStartPrice
+			.sub(order.auctionEndPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	}
+
+	let price;
+	if (isVariant(order.direction, 'long')) {
+		price = order.auctionStartPrice.add(priceDelta);
+	} else {
+		price = order.auctionStartPrice.sub(priceDelta);
+	}
+
+	return price;
+}
+
+/**
+ *
+ * @param order
+ * @param slot
+ * @param oraclePrice Use MMOraclePriceData source for perp orders, OraclePriceData for spot
+ * @returns
+ */
+export function getAuctionPriceForOracleOffsetAuction(
+	order: Order,
+	slot: number,
+	oraclePrice: BN
+): BN {
+	const slotsElapsed = new BN(slot).sub(order.slot);
+
+	const deltaDenominator = new BN(order.auctionDuration);
+	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
+
+	if (deltaDenominator.eq(ZERO)) {
+		return BN.max(oraclePrice.add(order.auctionEndPrice), ONE);
+	}
+
+	let priceOffsetDelta;
+	if (isVariant(order.direction, 'long')) {
+		priceOffsetDelta = order.auctionEndPrice
+			.sub(order.auctionStartPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	} else {
+		priceOffsetDelta = order.auctionStartPrice
+			.sub(order.auctionEndPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	}
+
+	let priceOffset;
+	if (isVariant(order.direction, 'long')) {
+		priceOffset = order.auctionStartPrice.add(priceOffsetDelta);
+	} else {
+		priceOffset = order.auctionStartPrice.sub(priceOffsetDelta);
+	}
+
+	return BN.max(oraclePrice.add(priceOffset), ONE);
+}
+
+export function deriveOracleAuctionParams({
+	direction,
+	oraclePrice,
+	auctionStartPrice,
+	auctionEndPrice,
+	limitPrice,
+	auctionPriceCaps,
+}: {
+	direction: PositionDirection;
+	oraclePrice: BN;
+	auctionStartPrice: BN;
+	auctionEndPrice: BN;
+	limitPrice: BN;
+	auctionPriceCaps?: {
+		min: BN;
+		max: BN;
+	};
+}): { auctionStartPrice: BN; auctionEndPrice: BN; oraclePriceOffset: number } {
+	let oraclePriceOffset;
+
+	if (limitPrice.eq(ZERO) || oraclePrice.eq(ZERO)) {
+		oraclePriceOffset = ZERO;
+	} else {
+		oraclePriceOffset = limitPrice.sub(oraclePrice);
+	}
+
+	if (oraclePriceOffset.eq(ZERO)) {
+		oraclePriceOffset = isVariant(direction, 'long')
+			? auctionEndPrice.sub(oraclePrice).add(ONE)
+			: auctionEndPrice.sub(oraclePrice).sub(ONE);
+	}
+
+	let oraclePriceOffsetNum;
+	try {
+		oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+	} catch (e) {
+		oraclePriceOffsetNum = 0;
+	}
+
+	if (auctionPriceCaps) {
+		auctionStartPrice = BN.min(
+			BN.max(auctionStartPrice, auctionPriceCaps.min),
+			auctionPriceCaps.max
+		);
+		auctionEndPrice = BN.min(
+			BN.max(auctionEndPrice, auctionPriceCaps.min),
+			auctionPriceCaps.max
+		);
+	}
+
+	return {
+		auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+		auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+		oraclePriceOffset: oraclePriceOffsetNum,
+	};
+}
+
+/**
+ *
+ * @param params Use OraclePriceData.price for oraclePrice param
+ * @returns
+ */
+export function getTriggerAuctionStartPrice(params: {
+	perpMarket: PerpMarketAccount;
+	direction: PositionDirection;
+	oraclePrice: BN;
+	limitPrice?: BN;
+}): BN {
+	const { perpMarket, direction, oraclePrice, limitPrice } = params;
+
+	const twapMismatch =
+		perpMarket.amm.historicalOracleData.lastOraclePriceTwapTs
+			.sub(perpMarket.amm.lastMarkPriceTwapTs)
+			.abs()
+			.gte(new BN(60)) ||
+		perpMarket.amm.volume24H.lte(new BN(100_000).mul(QUOTE_PRECISION));
+
+	let baselineStartOffset: BN;
+
+	if (twapMismatch) {
+		const contractTierNumber = getPerpMarketTierNumber(perpMarket);
+		const priceDivisor = contractTierNumber <= 1 ? 500 : 100;
+		baselineStartOffset = isVariant(direction, 'long')
+			? perpMarket.amm.lastBidPriceTwap.divn(priceDivisor)
+			: perpMarket.amm.lastAskPriceTwap.divn(priceDivisor).neg();
+	} else {
+		const markTwapSlow = isVariant(direction, 'long')
+			? perpMarket.amm.lastBidPriceTwap
+			: perpMarket.amm.lastAskPriceTwap;
+
+		const markTwapFast = perpMarket.amm.lastMarkPriceTwap5Min;
+		const oracleTwapSlow =
+			perpMarket.amm.historicalOracleData.lastOraclePriceTwap;
+		const oracleTwapFast =
+			perpMarket.amm.historicalOracleData.lastOraclePriceTwap5Min;
+
+		const offsetSlow = markTwapSlow.sub(oracleTwapSlow);
+		const offsetFast = markTwapFast.sub(oracleTwapFast);
+
+		const fracOfLongSpreadInPrice = new BN(perpMarket.amm.longSpread)
+			.mul(markTwapSlow)
+			.div(PRICE_PRECISION.muln(10)); // divide by 10x for safety
+
+		const fracOfShortSpreadInPrice = new BN(perpMarket.amm.shortSpread)
+			.mul(markTwapSlow)
+			.div(PRICE_PRECISION.muln(10)); // divide by 10x for safety
+
+		baselineStartOffset = isVariant(direction, 'long')
+			? BN.min(
+					offsetSlow.add(fracOfLongSpreadInPrice),
+					offsetFast.sub(fracOfShortSpreadInPrice)
+			  )
+			: BN.max(
+					offsetSlow.sub(fracOfShortSpreadInPrice),
+					offsetFast.add(fracOfLongSpreadInPrice)
+			  );
+	}
+
+	let startBuffer = -3500;
+
+	if (
+		isVariant(perpMarket.contractTier, 'a') ||
+		isVariant(perpMarket.contractTier, 'b')
+	) {
+		startBuffer = -500;
+	}
+
+	// Apply start buffer (in BPS)
+	const startBufferPrice = oraclePrice
+		.mul(new BN(startBuffer))
+		.div(new BN(PRICE_PRECISION));
+
+	let auctionStartPrice = isVariant(direction, 'long')
+		? oraclePrice.add(baselineStartOffset).sub(startBufferPrice)
+		: oraclePrice.add(baselineStartOffset).add(startBufferPrice);
+
+	if (limitPrice) {
+		if (isVariant(direction, 'long')) {
+			auctionStartPrice = BN.min(auctionStartPrice, limitPrice);
+		} else {
+			auctionStartPrice = BN.max(auctionStartPrice, limitPrice);
+		}
+	}
+
+	return auctionStartPrice;
+}
+
+/**
+ *
+ * @param params Use OraclePriceData.price for oraclePrice param and MMOraclePriceData.price for mmOraclePrice
+ * @returns
+ */
+export function getTriggerAuctionStartAndExecutionPrice(params: {
+	perpMarket: PerpMarketAccount;
+	direction: PositionDirection;
+	oraclePrice: BN;
+	mmOraclePrice: BN;
+	limitPrice?: BN;
+}): { startPrice: BN; executionPrice: BN } {
+	const { perpMarket, direction, oraclePrice, limitPrice, mmOraclePrice } =
+		params;
+
+	const startPrice = getTriggerAuctionStartPrice({
+		perpMarket,
+		direction,
+		oraclePrice,
+		limitPrice,
+	});
+
+	const offsetPlusBuffer = startPrice.sub(oraclePrice);
+	let executionPrice = mmOraclePrice.add(offsetPlusBuffer);
+
+	if (limitPrice) {
+		if (isVariant(direction, 'long')) {
+			executionPrice = BN.min(executionPrice, limitPrice);
+		} else {
+			executionPrice = BN.max(executionPrice, limitPrice);
+		}
+	}
+
+	return { startPrice, executionPrice };
+}

package/src/math/bankruptcy.ts

@@ -0,0 +1,35 @@
+import { ZERO } from '../constants/numericConstants';
+import { hasOpenOrders } from './position';
+import { isVariant } from '../types';
+import { User } from '../user';
+
+export function isUserBankrupt(user: User): boolean {
+	const userAccount = user.getUserAccount();
+	let hasLiability = false;
+	for (const position of userAccount.spotPositions) {
+		if (position.scaledBalance.gt(ZERO)) {
+			if (isVariant(position.balanceType, 'deposit')) {
+				return false;
+			}
+			if (isVariant(position.balanceType, 'borrow')) {
+				hasLiability = true;
+			}
+		}
+	}
+
+	for (const position of userAccount.perpPositions) {
+		if (
+			!position.baseAssetAmount.eq(ZERO) ||
+			position.quoteAssetAmount.gt(ZERO) ||
+			hasOpenOrders(position)
+		) {
+			return false;
+		}
+
+		if (position.quoteAssetAmount.lt(ZERO)) {
+			hasLiability = true;
+		}
+	}
+
+	return hasLiability;
+}

package/src/math/builder.ts

@@ -0,0 +1,20 @@
+import { RevenueShareOrder } from '../types';
+
+const FLAG_IS_OPEN = 0x01;
+export function isBuilderOrderOpen(order: RevenueShareOrder): boolean {
+	return (order.bitFlags & FLAG_IS_OPEN) !== 0;
+}
+
+const FLAG_IS_COMPLETED = 0x02;
+export function isBuilderOrderCompleted(order: RevenueShareOrder): boolean {
+	return (order.bitFlags & FLAG_IS_COMPLETED) !== 0;
+}
+
+const FLAG_IS_REFERRAL = 0x04;
+export function isBuilderOrderReferral(order: RevenueShareOrder): boolean {
+	return (order.bitFlags & FLAG_IS_REFERRAL) !== 0;
+}
+
+export function isBuilderOrderAvailable(order: RevenueShareOrder): boolean {
+	return !isBuilderOrderOpen(order) && !isBuilderOrderCompleted(order);
+}

package/src/math/conversion.ts

@@ -0,0 +1,24 @@
+import { BN } from '../isomorphic/anchor';
+import { PRICE_PRECISION } from '../constants/numericConstants';
+
+export const convertToNumber = (
+	bigNumber: BN,
+	precision: BN = PRICE_PRECISION
+) => {
+	if (!bigNumber) return 0;
+	return (
+		bigNumber.div(precision).toNumber() +
+		bigNumber.mod(precision).toNumber() / precision.toNumber()
+	);
+};
+
+export function convertToBN(value: number, precision: BN): BN {
+	// Get the whole part using Math.floor
+	const wholePart = Math.floor(value);
+
+	// Get decimal part by subtracting whole part and multiplying by precision
+	const decimalPart = Math.round((value - wholePart) * precision.toNumber());
+
+	// Combine: wholePart * PRECISION + decimalPart
+	return new BN(wholePart).mul(precision).add(new BN(decimalPart));
+}

package/src/math/exchangeStatus.ts

@@ -0,0 +1,136 @@
+import {
+	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
+	PERCENTAGE_PRECISION,
+	ONE,
+} from '../constants/numericConstants';
+import {
+	ExchangeStatus,
+	PerpMarketAccount,
+	PerpOperation,
+	SpotMarketAccount,
+	SpotOperation,
+	StateAccount,
+	isVariant,
+	InsuranceFundOperation,
+	MarketConfigFlag,
+} from '../types';
+import { BN } from '../isomorphic/anchor';
+
+export function exchangePaused(state: StateAccount): boolean {
+	return state.exchangeStatus !== ExchangeStatus.ACTIVE;
+}
+
+export function fillPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	if (
+		(state.exchangeStatus & ExchangeStatus.FILL_PAUSED) ===
+		ExchangeStatus.FILL_PAUSED
+	) {
+		return true;
+	}
+
+	if (market.hasOwnProperty('amm')) {
+		return isOperationPaused(market.pausedOperations, PerpOperation.FILL);
+	} else {
+		return isOperationPaused(market.pausedOperations, SpotOperation.FILL);
+	}
+}
+
+export function ammPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	if (
+		(state.exchangeStatus & ExchangeStatus.AMM_PAUSED) ===
+		ExchangeStatus.AMM_PAUSED
+	) {
+		return true;
+	}
+
+	if (market.hasOwnProperty('amm')) {
+		const operationPaused = isOperationPaused(
+			market.pausedOperations,
+			PerpOperation.AMM_FILL
+		);
+		if (operationPaused) {
+			return true;
+		}
+		if (isAmmDrawdownPause(market as PerpMarketAccount)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function isOperationPaused(
+	pausedOperations: number,
+	operation: PerpOperation | SpotOperation | InsuranceFundOperation
+): boolean {
+	return (pausedOperations & operation) > 0;
+}
+
+export function isAmmDrawdownPause(market: PerpMarketAccount): boolean {
+	let quoteDrawdownLimitBreached: boolean;
+
+	if (
+		isVariant(market.contractTier, 'a') ||
+		isVariant(market.contractTier, 'b')
+	) {
+		quoteDrawdownLimitBreached = market.amm.netRevenueSinceLastFunding.lte(
+			DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.muln(400)
+		);
+	} else {
+		quoteDrawdownLimitBreached = market.amm.netRevenueSinceLastFunding.lte(
+			DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.muln(200)
+		);
+	}
+
+	if (quoteDrawdownLimitBreached) {
+		const percentDrawdown = market.amm.netRevenueSinceLastFunding
+			.mul(PERCENTAGE_PRECISION)
+			.div(BN.max(market.amm.totalFeeMinusDistributions, ONE));
+
+		let percentDrawdownLimitBreached: boolean;
+
+		if (isVariant(market.contractTier, 'a')) {
+			percentDrawdownLimitBreached = percentDrawdown.lte(
+				PERCENTAGE_PRECISION.divn(50).neg()
+			);
+		} else if (isVariant(market.contractTier, 'b')) {
+			percentDrawdownLimitBreached = percentDrawdown.lte(
+				PERCENTAGE_PRECISION.divn(33).neg()
+			);
+		} else if (isVariant(market.contractTier, 'c')) {
+			percentDrawdownLimitBreached = percentDrawdown.lte(
+				PERCENTAGE_PRECISION.divn(25).neg()
+			);
+		} else {
+			percentDrawdownLimitBreached = percentDrawdown.lte(
+				PERCENTAGE_PRECISION.divn(20).neg()
+			);
+		}
+
+		if (percentDrawdownLimitBreached) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function isMarketConfigFlagSet(
+	marketConfig: number,
+	flag: MarketConfigFlag
+): boolean {
+	return (marketConfig & flag) > 0;
+}
+
+export function isFormulaicKUpdateDisabled(market: PerpMarketAccount): boolean {
+	return isMarketConfigFlagSet(
+		market.marketConfig,
+		MarketConfigFlag.DISABLE_FORMULAIC_K_UPDATE
+	);
+}