@drift-labs/sdk 0.1.21-master.0 → 0.1.22

package/src/index.ts

@@ -23,6 +23,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

@@ -4,11 +4,25 @@ import {
 	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	AMM_RESERVE_PRECISION,
 } 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 +128,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 +158,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);
@@ -169,6 +178,30 @@ export function calculateAdjustKCost(
 
 	const cost = calculatePositionPNL(marketNewK, netUserPosition);
 
+	const p = PEG_PRECISION.mul(numerator).div(denomenator);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+	const delta = market.baseAssetAmount;
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+
+	const numer1 = PEG_PRECISION.sub(p).mul(y).div(PEG_PRECISION);
+	const numer20 = k
+		.mul(p)
+		.mul(p)
+		.div(PEG_PRECISION)
+		.div(PEG_PRECISION)
+		.div(x.mul(p).div(PEG_PRECISION).add(delta));
+	const numer21 = k.div(x.add(delta));
+
+	const formulaCost = numer21
+		.sub(numer20)
+		.sub(numer1)
+		.mul(market.amm.pegMultiplier)
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+	console.log(convertToNumber(formulaCost, QUOTE_PRECISION));
+
+	// p.div(p.mul(x).add(delta)).sub()
+
 	return cost;
 }
 
@@ -190,6 +223,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);
@@ -210,6 +244,17 @@ export function calculateRepegCost(
 
 	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
 
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const newQuoteAssetReserve = k.div(
+		market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount)
+	);
+	const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(
+		market.amm.quoteAssetReserve
+	);
+	const cost2 = deltaQuoteAssetReserves
+		.mul(market.amm.pegMultiplier.sub(newPeg))
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+	console.log(convertToNumber(cost2, QUOTE_PRECISION));
 	return cost;
 }
 
@@ -220,10 +265,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;
@@ -235,6 +276,7 @@ export function calculateTerminalPrice(market: Market) {
 			market.baseAssetAmount.abs(),
 			getSwapDirection('base', directionToClose)
 		);
+
 	const terminalPrice = newQuoteAssetReserve
 		.mul(MARK_PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
@@ -243,3 +285,116 @@ 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];
+	}
+}
+
+export function calculateBudgetedK(market: Market, cost: BN): [BN, BN] {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const numer1 = y.mul(d).mul(Q).div(AMM_RESERVE_PRECISION).div(PEG_PRECISION);
+	const numer2 = C.mul(x.add(d)).div(QUOTE_PRECISION);
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numerator = d
+		.mul(numer1.add(numer2))
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1
+		.add(denom2)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	console.log(numerator, denominator);
+	// const p = (numerator).div(denominator);
+
+	// const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+	// console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(market: Market, cost: BN): BN {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION)
+		.div(deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO))
+		.mul(PEG_PRECISION)
+		.div(QUOTE_PRECISION);
+	console.log(
+		Q.toNumber(),
+		'change by',
+		deltaPegMultiplier.toNumber() / MARK_PRICE_PRECISION.toNumber()
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}

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,44 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { isVariant, Order } from '../types';
+import { ZERO, TWO } 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;
+	}
+
+	const baseAssetAmountToFill = order.baseAssetAmount.sub(
+		order.baseAssetAmountFilled
+	);
+	// if order will flip position
+	if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(TWO))) {
+		return true;
+	}
+
+	return false;
+}

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,151 @@
+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,
+	userOrderId = 0
+): OrderParams {
+	return {
+		orderType: OrderType.LIMIT,
+		userOrderId,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		positionLimit: ZERO,
+		padding0: true,
+		padding1: ZERO,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition: OrderTriggerCondition.ABOVE,
+		triggerPrice: ZERO,
+		oraclePriceOffset: ZERO,
+	};
+}
+
+export function getTriggerMarketOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	triggerPrice: BN,
+	triggerCondition: OrderTriggerCondition,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false,
+	userOrderId = 0
+): OrderParams {
+	return {
+		orderType: OrderType.TRIGGER_MARKET,
+		userOrderId,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price: ZERO,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		positionLimit: ZERO,
+		padding0: true,
+		padding1: ZERO,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition,
+		triggerPrice,
+		oraclePriceOffset: ZERO,
+	};
+}
+
+export function getTriggerLimitOrderParams(
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	price: BN,
+	triggerPrice: BN,
+	triggerCondition: OrderTriggerCondition,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false,
+	userOrderId = 0
+): OrderParams {
+	return {
+		orderType: OrderType.TRIGGER_LIMIT,
+		userOrderId,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		positionLimit: ZERO,
+		padding0: true,
+		padding1: ZERO,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition,
+		triggerPrice,
+		oraclePriceOffset: ZERO,
+	};
+}
+
+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,
+		userOrderId: 0,
+		marketIndex,
+		direction,
+		quoteAssetAmount,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly: false,
+		immediateOrCancel: false,
+		positionLimit: ZERO,
+		padding0: true,
+		padding1: ZERO,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition: OrderTriggerCondition.ABOVE,
+		triggerPrice: ZERO,
+		oraclePriceOffset: ZERO,
+	};
+}