@drift-labs/sdk 0.2.0-master.4 → 0.2.0-temp.0

package/src/math/amm.ts

@@ -68,7 +68,6 @@ export function calculateOptimalPegAndBudget(
 		let newOptimalPeg: BN;
 		let newBudget: BN;
 		const targetPriceGap = markPriceBefore.sub(targetPrice);
-
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
@@ -412,8 +411,10 @@ export function calculateSpread(
 	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
 ): number {
+	let spread = amm.baseSpread / 2;
+
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return amm.baseSpread / 2;
+		return spread;
 	}
 
 	const markPrice = calculatePrice(
@@ -434,25 +435,54 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(markPrice);
 
-	const [longSpread, shortSpread] = calculateSpreadBN(
-		amm.baseSpread,
-		targetMarkSpreadPct,
-		confIntervalPct,
-		amm.maxSpread,
-		amm.quoteAssetReserve,
-		amm.terminalQuoteAssetReserve,
-		amm.pegMultiplier,
-		amm.netBaseAssetAmount,
-		markPrice,
-		amm.totalFeeMinusDistributions
-	);
+	// oracle retreat
+	if (
+		(isVariant(direction, 'long') && targetMarkSpreadPct.lt(ZERO)) ||
+		(isVariant(direction, 'short') && targetMarkSpreadPct.gt(ZERO))
+	) {
+		spread = Math.max(
+			spread,
+			targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber()
+		);
+	}
 
-	let spread: number;
+	// inventory skew
+	const MAX_INVENTORY_SKEW = 5;
+	if (
+		(amm.netBaseAssetAmount.gt(ZERO) && isVariant(direction, 'long')) ||
+		(amm.netBaseAssetAmount.lt(ZERO) && isVariant(direction, 'short')) ||
+		amm.totalFeeMinusDistributions.eq(ZERO)
+	) {
+		const netCostBasis = amm.quoteAssetAmountLong.sub(
+			amm.quoteAssetAmountShort
+		);
+		const netBaseAssetValue = amm.quoteAssetReserve
+			.sub(amm.terminalQuoteAssetReserve)
+			.mul(amm.pegMultiplier)
+			.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+
+		const localBaseAssetValue = amm.netBaseAssetAmount
+			.mul(markPrice)
+			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		const netPnl = netBaseAssetValue.sub(netCostBasis);
+		const localPnl = localBaseAssetValue.sub(netCostBasis);
+
+		let effectiveLeverage = MAX_INVENTORY_SKEW;
+		if (amm.totalFeeMinusDistributions.gt(ZERO)) {
+			effectiveLeverage =
+				localPnl.sub(netPnl).toNumber() /
+				(amm.totalFeeMinusDistributions.toNumber() + 1);
+		}
 
-	if (isVariant(direction, 'long')) {
-		spread = longSpread;
-	} else {
-		spread = shortSpread;
+		let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		const maxTargetSpread = BID_ASK_SPREAD_PRECISION.toNumber() / 50; // 2%
+		// cap the scale to attempt to only scale up to maxTargetSpread
+		// always let the oracle retreat methods go through 100%
+		if (spreadScale * spread > maxTargetSpread) {
+			spreadScale = Math.max(1.05, maxTargetSpread / spread);
+		}
+
+		spread *= spreadScale;
 	}
 
 	return spread;

package/src/math/auction.ts

@@ -2,11 +2,7 @@ import { isVariant, Order } from '../types';
 import { BN, 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));
+	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
 }
 
 export function getAuctionPrice(order: Order, slot: number): BN {

package/src/math/orders.ts

@@ -1,10 +1,9 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
+import { isOneOfVariant, isVariant, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { getAuctionPrice, isAuctionComplete } from './auction';
-import { calculateAskPrice, calculateBidPrice } from './market';
+import { getAuctionPrice } from './auction';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -121,7 +120,6 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -129,19 +127,7 @@ export function getLimitPrice(
 	if (!order.oraclePriceOffset.eq(ZERO)) {
 		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
-		if (isAuctionComplete(order, slot)) {
-			limitPrice = getAuctionPrice(order, slot);
-		} else if (!order.price.eq(ZERO)) {
-			limitPrice = order.price;
-		} else if (isVariant(order.direction, 'long')) {
-			const askPrice = calculateAskPrice(market, oraclePriceData);
-			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = askPrice.add(delta);
-		} else {
-			const bidPrice = calculateBidPrice(market, oraclePriceData);
-			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = bidPrice.sub(delta);
-		}
+		limitPrice = getAuctionPrice(order, slot);
 	} else {
 		limitPrice = order.price;
 	}

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, SwapDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -78,20 +78,28 @@ export function calculateTradeSlippage(
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
-	const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] =
-		calculateTradeAcquiredAmounts(
-			direction,
-			amount,
-			market,
-			inputAssetType,
-			oraclePriceData,
-			useSpread
-		);
+	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
+		direction,
+		amount,
+		market,
+		inputAssetType,
+		oraclePriceData,
+		useSpread
+	);
+
+	const swapDirection = isVariant(direction, 'long')
+		? SwapDirection.REMOVE
+		: SwapDirection.ADD;
+	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		market.amm.pegMultiplier,
+		swapDirection
+	);
 
-	const entryPrice = acquiredQuoteAssetAmount
+	const entryPrice = quoteAssetAmountAcquired
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.mul(MARK_PRICE_PRECISION)
-		.div(acquiredBaseReserve.abs());
+		.div(acquiredBase.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
@@ -108,8 +116,8 @@ export function calculateTradeSlippage(
 	}
 
 	const newPrice = calculatePrice(
-		amm.baseAssetReserve.sub(acquiredBaseReserve),
-		amm.quoteAssetReserve.sub(acquiredQuoteReserve),
+		amm.baseAssetReserve.sub(acquiredBase),
+		amm.quoteAssetReserve.sub(acquiredQuote),
 		amm.pegMultiplier
 	);
 
@@ -151,9 +159,9 @@ export function calculateTradeAcquiredAmounts(
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
-): [BN, BN, BN] {
+): [BN, BN] {
 	if (amount.eq(ZERO)) {
-		return [ZERO, ZERO, ZERO];
+		return [ZERO, ZERO];
 	}
 
 	const swapDirection = getSwapDirection(inputAssetType, direction);
@@ -177,13 +185,7 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	const acquiredQuoteAssetamount = calculateQuoteAssetAmountSwapped(
-		acquiredQuote.abs(),
-		amm.pegMultiplier,
-		swapDirection
-	);
-
-	return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+	return [acquiredBase, acquiredQuote];
 }
 
 /**

package/src/orderParams.ts

@@ -1,33 +1,154 @@
-import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
+import {
+	OrderParams,
+	OrderTriggerCondition,
+	OrderType,
+	PositionDirection,
+} from './types';
 import { BN } from '@project-serum/anchor';
+import { ZERO } from './constants/numericConstants';
 
 export function getLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
-): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.LIMIT });
+	marketIndex: BN,
+	direction: PositionDirection,
+	baseAssetAmount: BN,
+	price: BN,
+	reduceOnly: boolean,
+	discountToken = false,
+	referrer = false,
+	userOrderId = 0,
+	postOnly = false,
+	oraclePriceOffset = ZERO,
+	immediateOrCancel = false
+): OrderParams {
+	return {
+		orderType: OrderType.LIMIT,
+		userOrderId,
+		marketIndex,
+		direction,
+		quoteAssetAmount: ZERO,
+		baseAssetAmount,
+		price,
+		reduceOnly,
+		postOnly,
+		immediateOrCancel,
+		positionLimit: ZERO,
+		padding0: true,
+		padding1: ZERO,
+		optionalAccounts: {
+			discountToken,
+			referrer,
+		},
+		triggerCondition: OrderTriggerCondition.ABOVE,
+		triggerPrice: ZERO,
+		oraclePriceOffset,
+	};
 }
 
 export function getTriggerMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
-		triggerCondition: OrderTriggerCondition;
-		triggerPrice: BN;
-	}
-): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
+	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(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
-		triggerCondition: OrderTriggerCondition;
-		triggerPrice: BN;
-		price: BN;
-	}
-): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
+	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(
-	params: Omit<OptionalOrderParams, 'orderType'>
-): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.MARKET });
+	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,
+	};
 }

package/src/types.ts

@@ -1,5 +1,5 @@
 import { PublicKey, Transaction } from '@solana/web3.js';
-import { BN, ZERO } from '.';
+import { BN } from '.';
 
 // # Utility Types / Enums / Constants
 export class SwapDirection {
@@ -51,19 +51,6 @@ export class OrderAction {
 	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 {
 	static readonly ABOVE = { above: {} };
 	static readonly BELOW = { below: {} };
@@ -177,10 +164,7 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
-	takerUnsettledPnl: BN;
-	makerUnsettledPnl: BN;
 	action: OrderAction;
-	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
 	fillRecordId: BN;
 	marketIndex: BN;
@@ -277,8 +261,6 @@ export type AMM = {
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
 	lastOraclePriceTwapTs: BN;
-	lastOracleMarkSpreadPct: BN;
-	lastOracleConfPct: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -293,8 +275,6 @@ export type AMM = {
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
-	maxBaseAssetAmountRatio: number;
-	maxSlippageRatio: number;
 	lastOraclePrice: BN;
 	baseSpread: number;
 	curveUpdateIntensity: number;
@@ -385,6 +365,7 @@ export type OrderParams = {
 	orderType: OrderType;
 	userOrderId: number;
 	direction: PositionDirection;
+	quoteAssetAmount: BN;
 	baseAssetAmount: BN;
 	price: BN;
 	marketIndex: BN;
@@ -403,39 +384,6 @@ 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;