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

package/src/math/auction.ts

@@ -0,0 +1,173 @@
+import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import { BN, getVariant, ONE, ZERO } from '../.';
+
+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,
+	minAuctionDuration: number,
+	slot: number
+): boolean {
+	if (minAuctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(minAuctionDuration));
+}
+
+export function getAuctionPrice(
+	order: Order,
+	slot: number,
+	oraclePrice: BN
+): BN {
+	if (
+		isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'triggerLimit'])
+	) {
+		return getAuctionPriceForFixedAuction(order, slot);
+	} else if (isVariant(order.orderType, 'limit')) {
+		if (order.oraclePriceOffset !== 0) {
+			return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+		} else {
+			return getAuctionPriceForFixedAuction(order, slot);
+		}
+	} else if (isVariant(order.orderType, 'oracle')) {
+		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;
+}
+
+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,
+	};
+}

package/src/math/bankruptcy.ts

@@ -0,0 +1,34 @@
+import { ZERO, hasOpenOrders, isVariant } from '..';
+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) ||
+			position.lpShares.gt(ZERO)
+		) {
+			return false;
+		}
+
+		if (position.quoteAssetAmount.lt(ZERO)) {
+			hasLiability = true;
+		}
+	}
+
+	return hasLiability;
+}

package/src/math/conversion.ts

@@ -0,0 +1,13 @@
+import { BN } from '../';
+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()
+	);
+};

package/src/math/exchangeStatus.ts

@@ -0,0 +1,121 @@
+import {
+	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
+	PERCENTAGE_PRECISION,
+	ONE,
+} from '../constants/numericConstants';
+import {
+	ExchangeStatus,
+	PerpMarketAccount,
+	PerpOperation,
+	SpotMarketAccount,
+	SpotOperation,
+	StateAccount,
+	isVariant,
+	InsuranceFundOperation,
+} from '../types';
+import { BN } from '@coral-xyz/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;
+}

package/src/math/fuel.ts

@@ -0,0 +1,70 @@
+import { BN } from '@coral-xyz/anchor';
+import { SpotMarketAccount, PerpMarketAccount } from '..';
+import {
+	QUOTE_PRECISION,
+	ZERO,
+	FUEL_WINDOW,
+} from '../constants/numericConstants';
+
+export function calculateInsuranceFuelBonus(
+	spotMarket: SpotMarketAccount,
+	tokenStakeAmount: BN,
+	fuelBonusNumerator: BN
+): BN {
+	const result = tokenStakeAmount
+		.abs()
+		.mul(fuelBonusNumerator)
+		.mul(new BN(spotMarket.fuelBoostInsurance))
+		.div(FUEL_WINDOW)
+		.div(QUOTE_PRECISION.div(new BN(10)));
+	return result;
+}
+
+export function calculateSpotFuelBonus(
+	spotMarket: SpotMarketAccount,
+	signedTokenValue: BN,
+	fuelBonusNumerator: BN
+): BN {
+	let result: BN;
+
+	if (signedTokenValue.abs().lte(QUOTE_PRECISION)) {
+		result = ZERO;
+	} else if (signedTokenValue.gt(new BN(0))) {
+		result = signedTokenValue
+			.abs()
+			.mul(fuelBonusNumerator)
+			.mul(new BN(spotMarket.fuelBoostDeposits))
+			.div(FUEL_WINDOW)
+			.div(QUOTE_PRECISION.div(new BN(10)));
+	} else {
+		result = signedTokenValue
+			.abs()
+			.mul(fuelBonusNumerator)
+			.mul(new BN(spotMarket.fuelBoostBorrows))
+			.div(FUEL_WINDOW)
+			.div(QUOTE_PRECISION.div(new BN(10)));
+	}
+
+	return result;
+}
+
+export function calculatePerpFuelBonus(
+	perpMarket: PerpMarketAccount,
+	baseAssetValue: BN,
+	fuelBonusNumerator: BN
+): BN {
+	let result: BN;
+
+	if (baseAssetValue.abs().lte(QUOTE_PRECISION)) {
+		result = new BN(0);
+	} else {
+		result = baseAssetValue
+			.abs()
+			.mul(fuelBonusNumerator)
+			.mul(new BN(perpMarket.fuelBoostPosition))
+			.div(FUEL_WINDOW)
+			.div(QUOTE_PRECISION.div(new BN(10)));
+	}
+
+	return result;
+}