@drift-labs/sdk-browser 2.104.0-beta.21

package/src/math/oracles.ts

@@ -0,0 +1,228 @@
+import { AMM, OracleGuardRails, isVariant } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_PRECISION,
+	ONE,
+	ZERO,
+	FIVE_MINUTE,
+	PERCENTAGE_PRECISION,
+} from '../constants/numericConstants';
+import { BN, HistoricalOracleData, PerpMarketAccount } from '../index';
+import { assert } from '../assert/assert';
+
+export function oraclePriceBands(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const maxPercentDiff =
+		market.marginRatioInitial - market.marginRatioMaintenance;
+	const offset = oraclePriceData.price
+		.mul(new BN(maxPercentDiff))
+		.div(MARGIN_PRECISION);
+
+	assert(offset.gte(ZERO));
+
+	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
+
+export function getMaxConfidenceIntervalMultiplier(
+	market: PerpMarketAccount
+): BN {
+	let maxConfidenceIntervalMultiplier;
+	if (isVariant(market.contractTier, 'a')) {
+		maxConfidenceIntervalMultiplier = new BN(1);
+	} else if (isVariant(market.contractTier, 'b')) {
+		maxConfidenceIntervalMultiplier = new BN(1);
+	} else if (isVariant(market.contractTier, 'c')) {
+		maxConfidenceIntervalMultiplier = new BN(2);
+	} else if (isVariant(market.contractTier, 'speculative')) {
+		maxConfidenceIntervalMultiplier = new BN(10);
+	} else {
+		maxConfidenceIntervalMultiplier = new BN(50);
+	}
+	return maxConfidenceIntervalMultiplier;
+}
+
+export function isOracleValid(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	slot: number
+): boolean {
+	// checks if oracle is valid for an AMM only fill
+
+	const amm = market.amm;
+	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
+	const isOraclePriceTooVolatile =
+		oraclePriceData.price
+			.div(BN.max(ONE, amm.historicalOracleData.lastOraclePriceTwap))
+			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
+		amm.historicalOracleData.lastOraclePriceTwap
+			.div(BN.max(ONE, oraclePriceData.price))
+			.gt(oracleGuardRails.validity.tooVolatileRatio);
+
+	const maxConfidenceIntervalMultiplier =
+		getMaxConfidenceIntervalMultiplier(market);
+	const isConfidenceTooLarge = BN.max(ONE, oraclePriceData.confidence)
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price)
+		.gt(
+			oracleGuardRails.validity.confidenceIntervalMaxSize.mul(
+				maxConfidenceIntervalMultiplier
+			)
+		);
+
+	const oracleIsStale = new BN(slot)
+		.sub(oraclePriceData.slot)
+		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
+
+	return !(
+		!oraclePriceData.hasSufficientNumberOfDataPoints ||
+		oracleIsStale ||
+		isOraclePriceNonPositive ||
+		isOraclePriceTooVolatile ||
+		isConfidenceTooLarge
+	);
+}
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
+	const sinceStart = BN.max(ZERO, FIVE_MINUTE.sub(sinceLastUpdate));
+	const oracleTwap5min = amm.historicalOracleData.lastOraclePriceTwap5Min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread.mul(PRICE_PRECISION).div(oracleTwap5min);
+
+	const maxDivergence = BN.max(
+		oracleGuardRails.priceDivergence.markOraclePercentDivergence,
+		PERCENTAGE_PRECISION.div(new BN(10))
+	);
+
+	const tooDivergent = oracleSpreadPct.abs().gte(maxDivergence);
+
+	return tooDivergent;
+}
+
+export function calculateLiveOracleTwap(
+	histOracleData: HistoricalOracleData,
+	oraclePriceData: OraclePriceData,
+	now: BN,
+	period: BN
+): BN {
+	let oracleTwap = undefined;
+	if (period.eq(FIVE_MINUTE)) {
+		oracleTwap = histOracleData.lastOraclePriceTwap5Min;
+	} else {
+		//todo: assumes its fundingPeriod (1hr)
+		// period = amm.fundingPeriod;
+		oracleTwap = histOracleData.lastOraclePriceTwap;
+	}
+
+	const sinceLastUpdate = BN.max(
+		ONE,
+		now.sub(histOracleData.lastOraclePriceTwapTs)
+	);
+	const sinceStart = BN.max(ZERO, period.sub(sinceLastUpdate));
+
+	const clampRange = oracleTwap.div(new BN(3));
+
+	const clampedOraclePrice = BN.min(
+		oracleTwap.add(clampRange),
+		BN.max(oraclePriceData.price, oracleTwap.sub(clampRange))
+	);
+
+	const newOracleTwap = oracleTwap
+		.mul(sinceStart)
+		.add(clampedOraclePrice.mul(sinceLastUpdate))
+		.div(sinceStart.add(sinceLastUpdate));
+
+	return newOracleTwap;
+}
+
+export function calculateLiveOracleStd(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	now: BN
+): BN {
+	const sinceLastUpdate = BN.max(
+		ONE,
+		now.sub(amm.historicalOracleData.lastOraclePriceTwapTs)
+	);
+	const sinceStart = BN.max(ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+
+	const liveOracleTwap = calculateLiveOracleTwap(
+		amm.historicalOracleData,
+		oraclePriceData,
+		now,
+		amm.fundingPeriod
+	);
+
+	const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();
+
+	const oracleStd = priceDeltaVsTwap.add(
+		amm.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate))
+	);
+
+	return oracleStd;
+}
+
+export function getNewOracleConfPct(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	reservePrice: BN,
+	now: BN
+): BN {
+	const confInterval = oraclePriceData.confidence || ZERO;
+
+	const sinceLastUpdate = BN.max(
+		ZERO,
+		now.sub(amm.historicalOracleData.lastOraclePriceTwapTs)
+	);
+	let lowerBoundConfPct = amm.lastOracleConfPct;
+	if (sinceLastUpdate.gt(ZERO)) {
+		const lowerBoundConfDivisor = BN.max(
+			new BN(21).sub(sinceLastUpdate),
+			new BN(5)
+		);
+		lowerBoundConfPct = amm.lastOracleConfPct.sub(
+			amm.lastOracleConfPct.div(lowerBoundConfDivisor)
+		);
+	}
+	const confIntervalPct = confInterval
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(reservePrice);
+
+	const confIntervalPctResult = BN.max(confIntervalPct, lowerBoundConfPct);
+
+	return confIntervalPctResult;
+}
+
+export function trimVaaSignatures(vaa: Buffer, n = 3): Buffer {
+	const currentNumSignatures = vaa[5];
+	if (n > currentNumSignatures) {
+		throw new Error(
+			"Resulting VAA can't have more signatures than the original VAA"
+		);
+	}
+
+	const trimmedVaa = Buffer.concat([
+		vaa.subarray(0, 6 + n * 66),
+		vaa.subarray(6 + currentNumSignatures * 66),
+	]);
+
+	trimmedVaa[5] = n;
+	return trimmedVaa;
+}

package/src/math/orders.ts

@@ -0,0 +1,343 @@
+import { User } from '../user';
+import {
+	isOneOfVariant,
+	isVariant,
+	PerpMarketAccount,
+	AMM,
+	Order,
+	PositionDirection,
+} from '../types';
+import { ZERO, TWO, ONE } from '../constants/numericConstants';
+import { BN } from '@coral-xyz/anchor';
+import { OraclePriceData } from '../oracles/types';
+import {
+	getAuctionPrice,
+	isAuctionComplete,
+	isFallbackAvailableLiquiditySource,
+} from './auction';
+import {
+	calculateMaxBaseAssetAmountFillable,
+	calculateMaxBaseAssetAmountToTrade,
+	calculateUpdatedAMM,
+} from './amm';
+
+export function isOrderRiskIncreasing(user: User, order: Order): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getPerpPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if no position exists, it's risk increasing
+	if (position.baseAssetAmount.eq(ZERO)) {
+		return true;
+	}
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return true;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return true;
+	}
+
+	const baseAssetAmountToFill = order.baseAssetAmount.sub(
+		order.baseAssetAmountFilled
+	);
+	// if order will flip position
+	if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(TWO))) {
+		return true;
+	}
+
+	return false;
+}
+
+export function isOrderRiskIncreasingInSameDirection(
+	user: User,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getPerpPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if no position exists, it's risk increasing
+	if (position.baseAssetAmount.eq(ZERO)) {
+		return true;
+	}
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return true;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+export function isOrderReduceOnly(user: User, order: Order): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getPerpPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if position is long and order is long
+	if (
+		position.baseAssetAmount.gte(ZERO) &&
+		isVariant(order.direction, 'long')
+	) {
+		return false;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lte(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return false;
+	}
+
+	return true;
+}
+
+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(
+	order: Order,
+	oraclePriceData: OraclePriceData,
+	slot: number,
+	fallbackPrice?: BN
+): BN | undefined {
+	let limitPrice;
+	if (hasAuctionPrice(order, slot)) {
+		limitPrice = getAuctionPrice(order, slot, oraclePriceData.price);
+	} else if (order.oraclePriceOffset !== 0) {
+		limitPrice = BN.max(
+			oraclePriceData.price.add(new BN(order.oraclePriceOffset)),
+			ONE
+		);
+	} else if (order.price.eq(ZERO)) {
+		limitPrice = fallbackPrice;
+	} else {
+		limitPrice = order.price;
+	}
+
+	return limitPrice;
+}
+
+export function hasLimitPrice(order: Order, slot: number): boolean {
+	return (
+		order.price.gt(ZERO) ||
+		order.oraclePriceOffset != 0 ||
+		!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,
+	oraclePriceData: OraclePriceData,
+	slot: number,
+	ts: number,
+	minAuctionDuration: number
+): boolean {
+	return (
+		(isFallbackAvailableLiquiditySource(order, minAuctionDuration, slot) &&
+			calculateBaseAssetAmountForAmmToFulfill(
+				order,
+				market,
+				oraclePriceData,
+				slot
+			).gte(market.amm.minOrderSize)) ||
+		isOrderExpired(order, ts)
+	);
+}
+
+export function calculateBaseAssetAmountForAmmToFulfill(
+	order: Order,
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	if (mustBeTriggered(order) && !isTriggered(order)) {
+		return ZERO;
+	}
+
+	const limitPrice = getLimitPrice(order, oraclePriceData, slot);
+	let baseAssetAmount;
+
+	const updatedAMM = calculateUpdatedAMM(market.amm, oraclePriceData);
+	if (limitPrice !== undefined) {
+		baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
+			order,
+			updatedAMM,
+			limitPrice,
+			oraclePriceData
+		);
+	} else {
+		baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+	}
+
+	const maxBaseAssetAmount = calculateMaxBaseAssetAmountFillable(
+		updatedAMM,
+		order.direction
+	);
+
+	return BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+
+export function calculateBaseAssetAmountToFillUpToLimitPrice(
+	order: Order,
+	amm: AMM,
+	limitPrice: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	const adjustedLimitPrice = isVariant(order.direction, 'long')
+		? limitPrice.sub(amm.orderTickSize)
+		: limitPrice.add(amm.orderTickSize);
+
+	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
+		amm,
+		adjustedLimitPrice,
+		order.direction,
+		oraclePriceData
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		amm.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);
+}
+
+export function isTakingOrder(order: Order, slot: number): boolean {
+	return isMarketOrder(order) || !isRestingLimitOrder(order, slot);
+}