@drift-labs/sdk 0.1.18-master.0 → 0.1.18-orders.1

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './mockUSDCFaucet';
 export * from './pythClient';
 export * from './types';
 export * from './constants/markets';
+export * from './accounts/defaultHistoryAccountSubscriber';
 export * from './accounts/defaultClearingHouseAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses';
@@ -17,6 +18,9 @@ export * from './math/market';
 export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
+export * from './math/orders';
+export * from './orders';
+export * from './orderParams';
 export * from './wallet';
 export * from './types';
 export * from './math/utils';

package/src/math/amm.ts

@@ -6,9 +6,20 @@ import {
 	ZERO,
 } from '../constants/numericConstants';
 import { calculateBaseAssetValue } from './position';
-import { AMM, PositionDirection, SwapDirection, Market } from '../types';
+import {
+	AMM,
+	PositionDirection,
+	SwapDirection,
+	Market,
+	isVariant,
+} from '../types';
 import { assert } from '../assert/assert';
-import { calculatePositionPNL, calculateMarkPrice, convertToNumber } from '..';
+import {
+	calculatePositionPNL,
+	calculateMarkPrice,
+	convertToNumber,
+	squareRootBN,
+} from '..';
 
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
@@ -114,17 +125,11 @@ export function getSwapDirection(
 	inputAssetType: AssetType,
 	positionDirection: PositionDirection
 ): SwapDirection {
-	if (
-		positionDirection === PositionDirection.LONG &&
-		inputAssetType === 'base'
-	) {
+	if (isVariant(positionDirection, 'long') && inputAssetType === 'base') {
 		return SwapDirection.REMOVE;
 	}
 
-	if (
-		positionDirection === PositionDirection.SHORT &&
-		inputAssetType === 'quote'
-	) {
+	if (isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
 		return SwapDirection.REMOVE;
 	}
 
@@ -150,6 +155,7 @@ export function calculateAdjustKCost(
 		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
 		marketIndex: new BN(marketIndex),
 		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
 	};
 
 	const currentValue = calculateBaseAssetValue(market, netUserPosition);
@@ -190,6 +196,7 @@ export function calculateRepegCost(
 		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
 		marketIndex: new BN(marketIndex),
 		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
 	};
 
 	const currentValue = calculateBaseAssetValue(market, netUserPosition);
@@ -220,10 +227,6 @@ export function calculateRepegCost(
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
 export function calculateTerminalPrice(market: Market) {
-	if (!market.initialized) {
-		return new BN(0);
-	}
-
 	const directionToClose = market.baseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
@@ -243,3 +246,33 @@ export function calculateTerminalPrice(market: Market) {
 
 	return terminalPrice;
 }
+
+export function calculateMaxBaseAssetAmountToTrade(
+	amm: AMM,
+	limit_price: BN
+): [BN, PositionDirection] {
+	const invariant = amm.sqrtK.mul(amm.sqrtK);
+
+	const newBaseAssetReserveSquared = invariant
+		.mul(MARK_PRICE_PRECISION)
+		.mul(amm.pegMultiplier)
+		.div(limit_price)
+		.div(PEG_PRECISION);
+
+	const newBaseAssetReserve = squareRootBN(newBaseAssetReserveSquared);
+
+	if (newBaseAssetReserve.gt(amm.baseAssetReserve)) {
+		return [
+			newBaseAssetReserve.sub(amm.baseAssetReserve),
+			PositionDirection.SHORT,
+		];
+	} else if (newBaseAssetReserve.lt(amm.baseAssetReserve)) {
+		return [
+			amm.baseAssetReserve.sub(newBaseAssetReserve),
+			PositionDirection.LONG,
+		];
+	} else {
+		console.log('tradeSize Too Small');
+		return [new BN(0), PositionDirection.LONG];
+	}
+}

package/src/math/market.ts

@@ -1,6 +1,10 @@
 import { BN } from '@project-serum/anchor';
-import { Market } from '../types';
-import { calculatePrice } from './amm';
+import { Market, PositionDirection } from '../types';
+import {
+	calculateAmmReservesAfterSwap,
+	calculatePrice,
+	getSwapDirection,
+} from './amm';
 
 /**
  * Calculates market mark price
@@ -15,3 +19,25 @@ export function calculateMarkPrice(market: Market): BN {
 		market.amm.pegMultiplier
 	);
 }
+
+export function calculateNewMarketAfterTrade(
+	baseAssetAmount: BN,
+	direction: PositionDirection,
+	market: Market
+): Market {
+	const [newQuoteAssetReserve, newBaseAssetReserve] =
+		calculateAmmReservesAfterSwap(
+			market.amm,
+			'base',
+			baseAssetAmount.abs(),
+			getSwapDirection('base', direction)
+		);
+
+	const newAmm = Object.assign({}, market.amm);
+	const newMarket = Object.assign({}, market);
+	newMarket.amm = newAmm;
+	newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+	newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+
+	return newMarket;
+}

package/src/math/orders.ts

@@ -0,0 +1,39 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { isVariant, Order } from '../types';
+import { ZERO } from '../constants/numericConstants';
+
+export function isOrderRiskIncreasing(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(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;
+	}
+
+	// if order will flip position
+	if (position.baseAssetAmount.abs().gt(order.baseAssetAmountFilled)) {
+		return true;
+	}
+}

package/src/math/position.ts

@@ -27,9 +27,7 @@ export function calculateBaseAssetValue(
 		return ZERO;
 	}
 
-	const directionToClose = userPosition.baseAssetAmount.gt(ZERO)
-		? PositionDirection.SHORT
-		: PositionDirection.LONG;
+	const directionToClose = findDirectionToClose(userPosition);
 
 	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
 		market.amm,
@@ -138,3 +136,25 @@ export function calculateEntryPrice(userPosition: UserPosition): BN {
 		.div(userPosition.baseAssetAmount)
 		.abs();
 }
+
+export function findDirectionToClose(
+	userPosition: UserPosition
+): PositionDirection {
+	return userPosition.baseAssetAmount.gt(ZERO)
+		? PositionDirection.SHORT
+		: PositionDirection.LONG;
+}
+
+export function positionCurrentDirection(
+	userPosition: UserPosition
+): PositionDirection {
+	return userPosition.baseAssetAmount.gte(ZERO)
+		? PositionDirection.LONG
+		: PositionDirection.SHORT;
+}
+
+export function isEmptyPosition(userPosition: UserPosition): boolean {
+	return (
+		userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders.eq(ZERO)
+	);
+}

package/src/orderParams.ts

@@ -0,0 +1,128 @@
+import {
+	OrderParams,
+	OrderTriggerCondition,
+	OrderType,
+	PositionDirection,
+} from './types';
+import { BN } from '@project-serum/anchor';
+import { ZERO } from './constants/numericConstants';
+
+export function getLimitOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	price: BN,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false
+): OrderParams {
+	return {
+		orderType: OrderType.LIMIT,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition: OrderTriggerCondition.ABOVE,
+		triggerPrice: ZERO,
+	};
+}
+
+export function getStopOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	triggerPrice: BN,
+	triggerCondition: OrderTriggerCondition,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false
+): OrderParams {
+	return {
+		orderType: OrderType.STOP,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price: ZERO,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition,
+		triggerPrice,
+	};
+}
+
+export function getStopLimitOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	price: BN,
+	triggerPrice: BN,
+	triggerCondition: OrderTriggerCondition,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false
+): OrderParams {
+	return {
+		orderType: OrderType.STOP_LIMIT,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition,
+		triggerPrice,
+	};
+}
+
+export function getMarketOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	quoteAssetAmount: BN,
+	baseAssetAmount: BN,
+	reduceOnly: boolean,
+	price = ZERO,
+	discountToken = false,
+	referrer = false
+): OrderParams {
+	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
+		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
+	}
+
+	return {
+		orderType: OrderType.MARKET,
+		marketIndex,
+		direction,
+		quoteAssetAmount,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition: OrderTriggerCondition.ABOVE,
+		triggerPrice: ZERO,
+	};
+}

package/src/orders.ts

@@ -0,0 +1,230 @@
+import {
+	isVariant,
+	Market,
+	Order,
+	PositionDirection,
+	UserAccount,
+	UserPosition,
+} from './types';
+import BN from 'bn.js';
+import {
+	calculateMarkPrice,
+	calculateNewMarketAfterTrade,
+} from './math/market';
+import {
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	PEG_PRECISION,
+	ZERO,
+} from './constants/numericConstants';
+import { calculateMaxBaseAssetAmountToTrade } from './math/amm';
+import {
+	findDirectionToClose,
+	positionCurrentDirection,
+} from './math/position';
+
+export function calculateNewStateAfterOrder(
+	userAccount: UserAccount,
+	userPosition: UserPosition,
+	market: Market,
+	order: Order
+): [UserAccount, UserPosition, Market] | null {
+	if (isVariant(order.status, 'init')) {
+		return null;
+	}
+
+	const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+		return null;
+	}
+
+	const userAccountAfter = Object.assign({}, userAccount);
+	const userPositionAfter = Object.assign({}, userPosition);
+
+	const currentPositionDirection = positionCurrentDirection(userPosition);
+	const increasePosition =
+		userPosition.baseAssetAmount.eq(ZERO) ||
+		isSameDirection(order.direction, currentPositionDirection);
+
+	if (increasePosition) {
+		const marketAfter = calculateNewMarketAfterTrade(
+			baseAssetAmountToTrade,
+			order.direction,
+			market
+		);
+
+		const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
+			calculateAmountSwapped(market, marketAfter);
+
+		userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
+			baseAssetAmountSwapped
+		);
+		userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(
+			quoteAssetAmountSwapped
+		);
+
+		return [userAccountAfter, userPositionAfter, marketAfter];
+	} else {
+		const reversePosition = baseAssetAmountToTrade.gt(
+			userPosition.baseAssetAmount.abs()
+		);
+
+		if (reversePosition) {
+			const intermediateMarket = calculateNewMarketAfterTrade(
+				userPosition.baseAssetAmount,
+				findDirectionToClose(userPosition),
+				market
+			);
+
+			const { quoteAssetAmountSwapped: baseAssetValue } =
+				calculateAmountSwapped(market, intermediateMarket);
+
+			let pnl;
+			if (isVariant(currentPositionDirection, 'long')) {
+				pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
+			} else {
+				pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
+			}
+
+			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+
+			const baseAssetAmountLeft = baseAssetAmountToTrade.sub(
+				userPosition.baseAssetAmount.abs()
+			);
+
+			const marketAfter = calculateNewMarketAfterTrade(
+				baseAssetAmountLeft,
+				order.direction,
+				intermediateMarket
+			);
+
+			const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
+				calculateAmountSwapped(intermediateMarket, marketAfter);
+
+			userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
+			userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
+
+			return [userAccountAfter, userPositionAfter, marketAfter];
+		} else {
+			const marketAfter = calculateNewMarketAfterTrade(
+				baseAssetAmountToTrade,
+				order.direction,
+				market
+			);
+
+			const {
+				quoteAssetAmountSwapped: baseAssetValue,
+				baseAssetAmountSwapped,
+			} = calculateAmountSwapped(market, marketAfter);
+
+			const costBasisRealized = userPosition.quoteAssetAmount
+				.mul(baseAssetAmountSwapped.abs())
+				.div(userPosition.baseAssetAmount.abs());
+
+			let pnl;
+			if (isVariant(currentPositionDirection, 'long')) {
+				pnl = baseAssetValue.sub(costBasisRealized);
+			} else {
+				pnl = costBasisRealized.sub(baseAssetValue);
+			}
+
+			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+
+			userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
+				baseAssetAmountSwapped
+			);
+			userPositionAfter.quoteAssetAmount =
+				userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
+
+			return [userAccountAfter, userPositionAfter, marketAfter];
+		}
+	}
+}
+
+function calculateAmountSwapped(
+	marketBefore: Market,
+	marketAfter: Market
+): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
+	return {
+		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
+			.sub(marketAfter.amm.quoteAssetReserve)
+			.abs()
+			.mul(marketBefore.amm.pegMultiplier)
+			.div(PEG_PRECISION)
+			.div(AMM_TO_QUOTE_PRECISION_RATIO),
+		baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(
+			marketAfter.amm.baseAssetReserve
+		),
+	};
+}
+
+function calculateAmountToTrade(market: Market, order: Order): BN {
+	if (isVariant(order.orderType, 'limit')) {
+		return calculateAmountToTradeForLimit(market, order);
+	} else if (isVariant(order.orderType, 'stopLimit')) {
+		return calculateAmountToTradeForStopLimit(market, order);
+	} else if (isVariant(order.orderType, 'market')) {
+		// should never be a market order queued
+		return ZERO;
+	} else {
+		return calculateAmountToTradeForStop(market, order);
+	}
+}
+
+export function calculateAmountToTradeForLimit(
+	market: Market,
+	order: Order
+): BN {
+	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
+		market.amm,
+		order.price
+	);
+
+	// Check that directions are the same
+	const sameDirection = isSameDirection(direction, order.direction);
+	if (!sameDirection) {
+		return ZERO;
+	}
+
+	return maxAmountToTrade.gt(order.baseAssetAmount)
+		? order.baseAssetAmount
+		: maxAmountToTrade;
+}
+
+export function calculateAmountToTradeForStopLimit(
+	market: Market,
+	order: Order
+): BN {
+	if (order.baseAssetAmountFilled.eq(ZERO)) {
+		const baseAssetAmount = calculateAmountToTradeForStop(market, order);
+		if (baseAssetAmount.eq(ZERO)) {
+			return ZERO;
+		}
+	}
+
+	return calculateAmountToTradeForLimit(market, order);
+}
+
+function isSameDirection(
+	firstDirection: PositionDirection,
+	secondDirection: PositionDirection
+): boolean {
+	return (
+		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
+		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
+	);
+}
+
+function calculateAmountToTradeForStop(market: Market, order: Order): BN {
+	return isTriggerConditionSatisfied(market, order)
+		? order.baseAssetAmount
+		: ZERO;
+}
+
+function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
+	const markPrice = calculateMarkPrice(market);
+	if (isVariant(order.triggerCondition, 'above')) {
+		return markPrice.gt(order.triggerPrice);
+	} else {
+		return markPrice.lt(order.triggerPrice);
+	}
+}