@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/math/auction.ts

@@ -1,371 +0,0 @@
-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.eq(ZERO)) {
-			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: BN } {
-	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);
-	}
-
-	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: oraclePriceOffset,
-	};
-}
-
-/**
- *
- * @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.marketStats.historicalOracleData.lastOraclePriceTwapTs
-			.sub(perpMarket.marketStats.lastMarkPriceTwapTs)
-			.abs()
-			.gte(new BN(60)) ||
-		perpMarket.marketStats.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.marketStats.lastBidPriceTwap.divn(priceDivisor)
-			: perpMarket.marketStats.lastAskPriceTwap.divn(priceDivisor).neg();
-	} else {
-		const markTwapSlow = isVariant(direction, 'long')
-			? perpMarket.marketStats.lastBidPriceTwap
-			: perpMarket.marketStats.lastAskPriceTwap;
-
-		const markTwapFast = perpMarket.marketStats.lastMarkPriceTwap5Min;
-		const oracleTwapSlow =
-			perpMarket.marketStats.historicalOracleData.lastOraclePriceTwap;
-		const oracleTwapFast =
-			perpMarket.marketStats.historicalOracleData.lastOraclePriceTwap5Min;
-
-		const offsetSlow = markTwapSlow.sub(oracleTwapSlow);
-		const offsetFast = markTwapFast.sub(oracleTwapFast);
-
-		// long_spread/short_spread were removed from AMM in the decoupling refactor.
-		// Fall back to half base_spread as the per-side spread approximation; the
-		// AMM no longer caches an exact per-side spread without oracle context.
-		const halfBaseSpread = new BN(Math.floor(perpMarket.amm.baseSpread / 2));
-		const fracOfLongSpreadInPrice = halfBaseSpread
-			.mul(markTwapSlow)
-			.div(PRICE_PRECISION.muln(10)); // divide by 10x for safety
-
-		const fracOfShortSpreadInPrice = halfBaseSpread
-			.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

@@ -1,35 +0,0 @@
-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.getUserAccountOrThrow();
-	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

@@ -1,64 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import {
-	OrderParams,
-	ReferrerStatus,
-	RevenueShareEscrowAccount,
-	RevenueShareOrder,
-	UserStatsAccount,
-} from '../types';
-
-/**
- * True when the user's RevenueShareEscrow was initialized with a referrer.
- * Fills for such users must include the escrow account or the program rejects
- * them with UnableToLoadRevenueShareAccount.
- */
-export function isBuilderReferral(
-	userStats: Pick<UserStatsAccount, 'referrerStatus'>
-): boolean {
-	return (userStats.referrerStatus & ReferrerStatus.BuilderReferral) !== 0;
-}
-
-/**
- * True when the escrow was initialized with a referrer. Referral rewards
- * accrue into such escrows on fills, so fills of the escrow owner's orders
- * must include the escrow account (see `isBuilderReferral`).
- */
-export function escrowHasReferrer(
-	escrow: Pick<RevenueShareEscrowAccount, 'referrer'>
-): boolean {
-	return !escrow.referrer.equals(PublicKey.default);
-}
-
-/**
- * True when the order params carry a builder code (`builderIdx` +
- * `builderFeeTenthBps`).
- */
-export function hasBuilderParams(
-	orderParams: Pick<OrderParams, 'builderIdx' | 'builderFeeTenthBps'>
-): boolean {
-	return (
-		orderParams.builderIdx !== null &&
-		orderParams.builderIdx !== undefined &&
-		orderParams.builderFeeTenthBps !== null &&
-		orderParams.builderFeeTenthBps !== undefined
-	);
-}
-
-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

@@ -1,24 +0,0 @@
-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

@@ -1,146 +0,0 @@
-import {
-	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
-	PERCENTAGE_PRECISION,
-	ONE,
-} from '../constants/numericConstants';
-import {
-	ExchangeStatus,
-	PerpMarketAccount,
-	PerpOperation,
-	SolvencyStatus,
-	SpotMarketAccount,
-	SpotOperation,
-	StateAccount,
-	isVariant,
-	InsuranceFundOperation,
-	MarketConfigFlag,
-} from '../types';
-import { BN } from '../isomorphic/anchor';
-
-export function exchangePaused(state: StateAccount): boolean {
-	return state.exchangeStatus !== ExchangeStatus.ACTIVE;
-}
-
-// Mirror of the program's `State::solvency_repair_paused`. Gates the resolve
-// bankruptcy / pnl-deficit instructions, independent of WITHDRAW_PAUSED.
-export function solvencyRepairPaused(state: StateAccount): boolean {
-	return (
-		(state.solvencyStatus & SolvencyStatus.SOLVENCY_REPAIR_PAUSED) ===
-		SolvencyStatus.SOLVENCY_REPAIR_PAUSED
-	);
-}
-
-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
-	);
-}