@drift-labs/sdk 0.1.23-master.2 → 0.1.23-master.3

package/lib/math/orders.d.ts

@@ -1,3 +1,4 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
 import { Order } from '../types';
 export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;
+export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;

package/lib/math/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrderRiskIncreasing = void 0;
+exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 function isOrderRiskIncreasing(user, order) {
@@ -30,3 +30,25 @@ function isOrderRiskIncreasing(user, order) {
     return false;
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
+function isOrderRiskIncreasingInSameDirection(user, order) {
+    if ((0, types_1.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(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;

package/lib/orders.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="bn.js" />
 import { Market, Order, UserAccount, UserPosition } from './types';
-import { BN } from '.';
+import { BN, ClearingHouseUser } from '.';
 export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
+export declare function calculateBaseAssetAmountMarketCanExecute(market: Market, order: Order): BN;
 export declare function calculateAmountToTradeForLimit(market: Market, order: Order): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;
+export declare function calculateBaseAssetAmountUserCanExecute(market: Market, order: Order, user: ClearingHouseUser): BN;

package/lib/orders.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
+const _1 = require(".");
 const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
 const amm_1 = require("./math/amm");
@@ -10,7 +11,7 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return null;
     }
-    const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
     if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
         return null;
     }
@@ -79,7 +80,7 @@ function calculateAmountSwapped(marketBefore, marketAfter) {
         baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
     };
 }
-function calculateAmountToTrade(market, order) {
+function calculateBaseAssetAmountMarketCanExecute(market, order) {
     if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order);
     }
@@ -94,6 +95,7 @@ function calculateAmountToTrade(market, order) {
         return calculateAmountToTradeForTriggerMarket(market, order);
     }
 }
+exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
 function calculateAmountToTradeForLimit(market, order) {
     const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, order.price);
     // Check that directions are the same
@@ -134,3 +136,29 @@ function isTriggerConditionSatisfied(market, order) {
         return markPrice.lt(order.triggerPrice);
     }
 }
+function calculateBaseAssetAmountUserCanExecute(market, order, user) {
+    const maxLeverage = user.getMaxLeverage('Initial');
+    const freeCollateral = user.getFreeCollateral();
+    let quoteAssetAmount;
+    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
+        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
+    }
+    else {
+        const position = user.getUserPosition(order.marketIndex) ||
+            user.getEmptyPosition(order.marketIndex);
+        const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
+        quoteAssetAmount = freeCollateral
+            .mul(maxLeverage)
+            .div(_1.TEN_THOUSAND)
+            .add(positionValue.mul(numericConstants_1.TWO));
+    }
+    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetReservesBefore = market.amm.baseAssetReserve;
+    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(market.amm, 'quote', quoteAssetAmount, (0, types_1.isVariant)(order.direction, 'long')
+        ? types_1.SwapDirection.ADD
+        : types_1.SwapDirection.REMOVE);
+    return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}
+exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.23-master.2",
+	"version": "0.1.23-master.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/math/orders.ts

@@ -42,3 +42,36 @@ export function isOrderRiskIncreasing(
 
 	return false;
 }
+
+export function isOrderRiskIncreasingInSameDirection(
+	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;
+	}
+
+	return false;
+}

package/src/orders.ts

@@ -3,16 +3,25 @@ import {
 	Market,
 	Order,
 	PositionDirection,
+	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import { BN } from '.';
+import {
+	BN,
+	calculateAmmReservesAfterSwap,
+	calculateBaseAssetValue,
+	ClearingHouseUser,
+	isOrderRiskIncreasingInSameDirection,
+	TEN_THOUSAND,
+} from '.';
 import {
 	calculateMarkPrice,
 	calculateNewMarketAfterTrade,
 } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -32,7 +41,10 @@ export function calculateNewStateAfterOrder(
 		return null;
 	}
 
-	const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
+		market,
+		order
+	);
 	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
 		return null;
 	}
@@ -157,7 +169,10 @@ function calculateAmountSwapped(
 	};
 }
 
-function calculateAmountToTrade(market: Market, order: Order): BN {
+export function calculateBaseAssetAmountMarketCanExecute(
+	market: Market,
+	order: Order
+): BN {
 	if (isVariant(order.orderType, 'limit')) {
 		return calculateAmountToTradeForLimit(market, order);
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
@@ -234,3 +249,41 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 		return markPrice.lt(order.triggerPrice);
 	}
 }
+
+export function calculateBaseAssetAmountUserCanExecute(
+	market: Market,
+	order: Order,
+	user: ClearingHouseUser
+): BN {
+	const maxLeverage = user.getMaxLeverage('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);
+		quoteAssetAmount = freeCollateral
+			.mul(maxLeverage)
+			.div(TEN_THOUSAND)
+			.add(positionValue.mul(TWO));
+	}
+
+	if (quoteAssetAmount.lte(ZERO)) {
+		return ZERO;
+	}
+
+	const baseAssetReservesBefore = market.amm.baseAssetReserve;
+	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
+		market.amm,
+		'quote',
+		quoteAssetAmount,
+		isVariant(order.direction, 'long')
+			? SwapDirection.ADD
+			: SwapDirection.REMOVE
+	);
+
+	return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}