@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.4

package/src/orders.ts

@@ -3,27 +3,13 @@ import {
 	MarketAccount,
 	Order,
 	PositionDirection,
-	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import {
-	BN,
-	calculateAmmReservesAfterSwap,
-	calculateBaseAssetValue,
-	calculateSpreadReserves,
-	ClearingHouseUser,
-	isOrderRiskIncreasingInSameDirection,
-	standardizeBaseAssetAmount,
-	TEN_THOUSAND,
-} from '.';
-import {
-	calculateMarkPrice,
-	calculateNewMarketAfterTrade,
-} from './math/market';
+import { BN, standardizeBaseAssetAmount } from '.';
+import { calculateNewMarketAfterTrade } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
-	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -182,7 +168,6 @@ export function calculateBaseAssetAmountMarketCanExecute(
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
 		return calculateAmountToTradeForTriggerLimit(market, order);
 	} else if (isVariant(order.orderType, 'market')) {
-		// should never be a market order queued
 		return ZERO;
 	} else {
 		return calculateAmountToTradeForTriggerMarket(market, order);
@@ -201,14 +186,7 @@ export function calculateAmountToTradeForLimit(
 				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
 			);
 		}
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
-		} else {
-			limitPrice = floatingPrice;
-		}
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	}
 
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
@@ -237,14 +215,8 @@ export function calculateAmountToTradeForTriggerLimit(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	if (order.baseAssetAmountFilled.eq(ZERO)) {
-		const baseAssetAmount = calculateAmountToTradeForTriggerMarket(
-			market,
-			order
-		);
-		if (baseAssetAmount.eq(ZERO)) {
-			return ZERO;
-		}
+	if (!order.triggered) {
+		return ZERO;
 	}
 
 	return calculateAmountToTradeForLimit(market, order);
@@ -264,105 +236,9 @@ function calculateAmountToTradeForTriggerMarket(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	return isTriggerConditionSatisfied(market, order)
-		? order.baseAssetAmount
-		: ZERO;
-}
-
-function isTriggerConditionSatisfied(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): boolean {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
-	if (isVariant(order.triggerCondition, 'above')) {
-		return markPrice.gt(order.triggerPrice);
-	} else {
-		return markPrice.lt(order.triggerPrice);
-	}
-}
-
-export function calculateBaseAssetAmountUserCanExecute(
-	market: MarketAccount,
-	order: Order,
-	user: ClearingHouseUser,
-	oraclePriceData?: OraclePriceData
-): BN {
-	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-	const freeCollateral = user.getFreeCollateral();
-	let quoteAssetAmount: BN;
-	if (isOrderRiskIncreasingInSameDirection(user, order)) {
-		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
-	} else {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
-		quoteAssetAmount = freeCollateral
-			.mul(maxLeverage)
-			.div(TEN_THOUSAND)
-			.add(positionValue.mul(TWO));
-	}
-
-	if (quoteAssetAmount.lte(ZERO)) {
+	if (!order.triggered) {
 		return ZERO;
 	}
 
-	const swapDirection = isVariant(order.direction, 'long')
-		? SwapDirection.ADD
-		: SwapDirection.REMOVE;
-
-	const useSpread = !order.postOnly;
-	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
-	if (useSpread) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			order.direction,
-			oraclePriceData
-		);
-		amm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
-		};
-	} else {
-		amm = market.amm;
-	}
-
-	const baseAssetReservesBefore = amm.baseAssetReserve;
-	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
-		amm,
-		'quote',
-		quoteAssetAmount,
-		swapDirection
-	);
-
-	let baseAssetAmount = baseAssetReservesBefore
-		.sub(baseAssetReservesAfter)
-		.abs();
-	if (order.reduceOnly) {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		if (
-			isVariant(order.direction, 'long') &&
-			position.baseAssetAmount.gte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else if (
-			isVariant(order.direction, 'short') &&
-			position.baseAssetAmount.lte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else {
-			BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-		}
-	}
-
-	return baseAssetAmount;
+	return order.baseAssetAmount;
 }

package/src/types.ts

@@ -1,5 +1,5 @@
 import { PublicKey, Transaction } from '@solana/web3.js';
-import { BN } from '.';
+import { BN, ZERO } from '.';
 
 // # Utility Types / Enums / Constants
 export class SwapDirection {
@@ -48,6 +48,20 @@ export class OrderAction {
 	static readonly CANCEL = { cancel: {} };
 	static readonly EXPIRE = { expire: {} };
 	static readonly FILL = { fill: {} };
+	static readonly TRIGGER = { trigger: {} };
+}
+
+export class OrderActionExplanation {
+	static readonly NONE = { none: {} };
+	static readonly BREACHED_MARGIN_REQUIREMENT = {
+		breachedMarginRequirement: {},
+	};
+	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+		oraclePriceBreachedLimitPrice: {},
+	};
+	static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+		marketOrderFilledToLimitPrice: {},
+	};
 }
 
 export class OrderTriggerCondition {
@@ -163,7 +177,10 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
+	takerUnsettledPnl: BN;
+	makerUnsettledPnl: BN;
 	action: OrderAction;
+	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
 	fillRecordId: BN;
 	marketIndex: BN;
@@ -260,6 +277,8 @@ export type AMM = {
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
 	lastOraclePriceTwapTs: BN;
+	lastOracleMarkSpreadPct: BN;
+	lastOracleConfPct: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -274,6 +293,8 @@ export type AMM = {
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
+	maxBaseAssetAmountRatio: number;
+	maxSlippageRatio: number;
 	lastOraclePrice: BN;
 	baseSpread: number;
 	curveUpdateIntensity: number;
@@ -290,6 +311,7 @@ export type AMM = {
 	lastAskPriceTwap: BN;
 	longSpread: BN;
 	shortSpread: BN;
+	maxSpread: number;
 };
 
 // # User Account Types
@@ -347,8 +369,9 @@ export type Order = {
 	reduceOnly: boolean;
 	triggerPrice: BN;
 	triggerCondition: OrderTriggerCondition;
+	triggered: boolean;
 	discountTier: OrderDiscountTier;
-	existingPositionDirection: PositionDirection,
+	existingPositionDirection: PositionDirection;
 	referrer: PublicKey;
 	postOnly: boolean;
 	immediateOrCancel: boolean;
@@ -362,7 +385,6 @@ export type OrderParams = {
 	orderType: OrderType;
 	userOrderId: number;
 	direction: PositionDirection;
-	quoteAssetAmount: BN;
 	baseAssetAmount: BN;
 	price: BN;
 	marketIndex: BN;
@@ -381,6 +403,39 @@ export type OrderParams = {
 	};
 };
 
+export type NecessaryOrderParams = {
+	orderType: OrderType;
+	marketIndex: BN;
+	baseAssetAmount: BN;
+	direction: PositionDirection;
+};
+
+export type OptionalOrderParams = {
+	[Property in keyof OrderParams]?: OrderParams[Property];
+} & NecessaryOrderParams;
+
+export const DefaultOrderParams = {
+	orderType: OrderType.MARKET,
+	userOrderId: 0,
+	direction: PositionDirection.LONG,
+	baseAssetAmount: ZERO,
+	price: ZERO,
+	marketIndex: ZERO,
+	reduceOnly: false,
+	postOnly: false,
+	immediateOrCancel: false,
+	triggerPrice: ZERO,
+	triggerCondition: OrderTriggerCondition.ABOVE,
+	positionLimit: ZERO,
+	oraclePriceOffset: ZERO,
+	padding0: ZERO,
+	padding1: ZERO,
+	optionalAccounts: {
+		discountToken: false,
+		referrer: false,
+	},
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	order: Order;