@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.5

package/src/math/amm.ts

@@ -68,6 +68,7 @@ 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);
 
@@ -411,10 +412,8 @@ export function calculateSpread(
 	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
 ): number {
-	let spread = amm.baseSpread / 2;
-
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return spread;
+		return amm.baseSpread / 2;
 	}
 
 	const markPrice = calculatePrice(
@@ -435,54 +434,25 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(markPrice);
 
-	// 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()
-		);
-	}
-
-	// 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);
-		}
+	const [longSpread, shortSpread] = calculateSpreadBN(
+		amm.baseSpread,
+		targetMarkSpreadPct,
+		confIntervalPct,
+		amm.maxSpread,
+		amm.quoteAssetReserve,
+		amm.terminalQuoteAssetReserve,
+		amm.pegMultiplier,
+		amm.netBaseAssetAmount,
+		markPrice,
+		amm.totalFeeMinusDistributions
+	);
 
-		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);
-		}
+	let spread: number;
 
-		spread *= spreadScale;
+	if (isVariant(direction, 'long')) {
+		spread = longSpread;
+	} else {
+		spread = shortSpread;
 	}
 
 	return spread;

package/src/math/auction.ts

@@ -2,7 +2,11 @@ import { isVariant, Order } from '../types';
 import { BN, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
-	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
 export function getAuctionPrice(order: Order, slot: number): BN {

package/src/math/orders.ts

@@ -1,9 +1,10 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { getAuctionPrice } from './auction';
+import { getAuctionPrice, isAuctionComplete } from './auction';
+import { calculateAskPrice, calculateBidPrice } from './market';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -120,24 +121,27 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
-		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);
+		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 {
-			limitPrice = floatingPrice;
+			const bidPrice = calculateBidPrice(market, oraclePriceData);
+			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = bidPrice.sub(delta);
 		}
-	} else if (
-		isVariant(order.orderType, 'market') ||
-		isVariant(order.orderType, 'triggerMarket')
-	) {
-		limitPrice = getAuctionPrice(order, slot);
 	} else {
 		limitPrice = order.price;
 	}

package/src/math/position.ts

@@ -153,7 +153,11 @@ export function calculatePositionFundingPNL(
 }
 
 export function positionIsAvailable(position: UserPosition): boolean {
-	return position.baseAssetAmount.eq(ZERO) && position.openOrders.eq(ZERO);
+	return (
+		position.baseAssetAmount.eq(ZERO) &&
+		position.openOrders.eq(ZERO) &&
+		position.unsettledPnl.eq(ZERO)
+	);
 }
 
 /**

package/src/math/trade.ts

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

package/src/orderParams.ts

@@ -1,154 +1,33 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
+import { OptionalOrderParams, OrderTriggerCondition, OrderType } 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,
-	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,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.LIMIT });
 }
 
 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,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
 }
 
 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,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
 }
 
 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,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'>
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.MARKET });
 }

package/src/orders.ts

@@ -186,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(

package/src/tx/utils.ts

@@ -8,7 +8,7 @@ const COMPUTE_UNITS_DEFAULT = 200_000;
 
 export function wrapInTx(
 	instruction: TransactionInstruction,
-	computeUnits = 500_000 // TODO, requires less code change
+	computeUnits = 600_000 // TODO, requires less code change
 ): Transaction {
 	const tx = new Transaction();
 	if (computeUnits != COMPUTE_UNITS_DEFAULT) {

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 {
@@ -17,6 +17,11 @@ export class PositionDirection {
 	static readonly SHORT = { short: {} };
 }
 
+export class DepositDirection {
+	static readonly DEPOSIT = { deposit: {} };
+	static readonly WITHDRAW = { withdraw: {} };
+}
+
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly SWITCHBOARD = { switchboard: {} };
@@ -51,6 +56,19 @@ 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: {} };
@@ -92,6 +110,7 @@ export type DepositRecord = {
 	};
 	bankIndex: BN;
 	amount: BN;
+	oraclePrice: BN;
 	from?: PublicKey;
 	to?: PublicKey;
 };
@@ -164,7 +183,10 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
+	takerUnsettledPnl: BN;
+	makerUnsettledPnl: BN;
 	action: OrderAction;
+	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
 	fillRecordId: BN;
 	marketIndex: BN;
@@ -261,6 +283,8 @@ export type AMM = {
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
 	lastOraclePriceTwapTs: BN;
+	lastOracleMarkSpreadPct: BN;
+	lastOracleConfPct: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -275,6 +299,8 @@ export type AMM = {
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
+	maxBaseAssetAmountRatio: number;
+	maxSlippageRatio: number;
 	lastOraclePrice: BN;
 	baseSpread: number;
 	curveUpdateIntensity: number;
@@ -365,7 +391,6 @@ export type OrderParams = {
 	orderType: OrderType;
 	userOrderId: number;
 	direction: PositionDirection;
-	quoteAssetAmount: BN;
 	baseAssetAmount: BN;
 	price: BN;
 	marketIndex: BN;
@@ -384,11 +409,49 @@ 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;
 };
 
+export type TakerInfo = {
+	taker: PublicKey;
+	order: Order;
+};
+
 // # Misc Types
 export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;