@drift-labs/sdk 0.1.12 → 0.1.13

package/src/clearingHouseUser.ts

@@ -4,6 +4,7 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouse } from './clearingHouse';
 import { UserAccount, UserPosition, UserPositionsAccount } from './types';
+import { calculateEntryPrice } from './math/position';
 import {
 	MARK_PRICE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -13,6 +14,8 @@ import {
 	PARTIAL_LIQUIDATION_RATIO,
 	FULL_LIQUIDATION_RATIO,
 	QUOTE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
 } from './constants/numericConstants';
 import { UserAccountSubscriber, UserAccountEvents } from './accounts/types';
 import { DefaultUserAccountSubscriber } from './accounts/defaultUserAccountSubscriber';
@@ -81,23 +84,25 @@ export class ClearingHouseUser {
 	}
 
 	/**
-	 * Gets the user's current position for a given market
+	 * Gets the user's current position for a given market. If the user has no position returns undefined
 	 * @param marketIndex
 	 * @returns userPosition
 	 */
-	public getUserPosition(marketIndex: BN): UserPosition {
-		return (
-			this.getUserPositionsAccount().positions.find((position) =>
-				position.marketIndex.eq(marketIndex)
-			) ?? {
-				baseAssetAmount: ZERO,
-				lastCumulativeFundingRate: ZERO,
-				marketIndex,
-				quoteAssetAmount: ZERO,
-			}
+	public getUserPosition(marketIndex: BN): UserPosition | undefined {
+		return this.getUserPositionsAccount().positions.find((position) =>
+			position.marketIndex.eq(marketIndex)
 		);
 	}
 
+	public getEmptyPosition(marketIndex: BN): UserPosition {
+		return {
+			baseAssetAmount: ZERO,
+			lastCumulativeFundingRate: ZERO,
+			marketIndex,
+			quoteAssetAmount: ZERO,
+		};
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		if (this.userAccountPublicKey) {
 			return this.userAccountPublicKey;
@@ -205,7 +210,8 @@ export class ClearingHouseUser {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getPositionValue(marketIndex: BN): BN {
-		const userPosition = this.getUserPosition(marketIndex);
+		const userPosition =
+			this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
 		const market = this.clearingHouse.getMarket(userPosition.marketIndex);
 		return calculateBaseAssetValue(market, userPosition);
 	}
@@ -226,15 +232,17 @@ export class ClearingHouseUser {
 	 * calculates average exit price for closing 100% of position
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
-	public getPositionEstimatedExitPrice(
+	public getPositionEstimatedExitPriceAndPnl(
 		position: UserPosition,
 		amountToClose?: BN
-	): BN {
+	): [BN, BN] {
 		const market = this.clearingHouse.getMarket(position.marketIndex);
 
+		const entryPrice = calculateEntryPrice(position);
+
 		if (amountToClose) {
 			if (amountToClose.eq(ZERO)) {
-				return calculateMarkPrice(market);
+				return [calculateMarkPrice(market), ZERO];
 			}
 			position = {
 				baseAssetAmount: amountToClose,
@@ -246,12 +254,21 @@ export class ClearingHouseUser {
 
 		const baseAssetValue = calculateBaseAssetValue(market, position);
 		if (position.baseAssetAmount.eq(ZERO)) {
-			return ZERO;
+			return [ZERO, ZERO];
 		}
-		return baseAssetValue
+
+		const exitPrice = baseAssetValue
 			.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 			.mul(MARK_PRICE_PRECISION)
 			.div(position.baseAssetAmount.abs());
+
+		const pnlPerBase = exitPrice.sub(entryPrice);
+		const pnl = pnlPerBase
+			.mul(position.baseAssetAmount)
+			.div(MARK_PRICE_PRECISION)
+			.div(AMM_TO_QUOTE_PRECISION_RATIO);
+
+		return [exitPrice, pnl];
 	}
 
 	/**
@@ -350,7 +367,7 @@ export class ClearingHouseUser {
 	 * @param partial
 	 * @returns Precision : MARK_PRICE_PRECISION
 	 */
-	public liquidationPrice(
+	public liquidationPriceOld(
 		targetMarket: Pick<UserPosition, 'marketIndex'>,
 		positionBaseSizeChange: BN = ZERO,
 		partial = false
@@ -379,13 +396,11 @@ export class ClearingHouseUser {
 		const totalCurrentPositionValueIgnoringTargetUSDC =
 			this.getTotalPositionValueExcludingMarket(targetMarket.marketIndex);
 
-		const currentMarketPosition = this.getUserPosition(
-			targetMarket.marketIndex
-		);
+		const currentMarketPosition =
+			this.getUserPosition(targetMarket.marketIndex) ||
+			this.getEmptyPosition(targetMarket.marketIndex);
 
-		const currentMarketPositionBaseSize = currentMarketPosition
-			? currentMarketPosition.baseAssetAmount
-			: ZERO;
+		const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
 
 		// calculate position for current market after trade
 		const proposedMarketPosition: UserPosition = {
@@ -412,9 +427,23 @@ export class ClearingHouseUser {
 				proposedMarketPositionValueUSDC
 			);
 
+		let totalFreeCollateralUSDC = this.getTotalCollateral().sub(
+			this.getTotalPositionValue()
+				.mul(TEN_THOUSAND)
+				.div(this.getMaxLeverage('Maintenance'))
+		);
+
+		if (partial) {
+			totalFreeCollateralUSDC = this.getTotalCollateral().sub(
+				this.getTotalPositionValue()
+					.mul(TEN_THOUSAND)
+					.div(this.getMaxLeverage('Partial'))
+			);
+		}
+
 		// if the position value after the trade is less than total collateral, there is no liq price
 		if (
-			targetTotalPositionValueUSDC.lte(totalCollateralUSDC) &&
+			targetTotalPositionValueUSDC.lte(totalFreeCollateralUSDC) &&
 			proposedMarketPosition.baseAssetAmount.gt(ZERO)
 		) {
 			return new BN(-1);
@@ -456,6 +485,127 @@ export class ClearingHouseUser {
 		return liqPrice;
 	}
 
+	/**
+	 * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
+	 * @param targetMarket
+	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+	 * @param partial
+	 * @returns Precision : MARK_PRICE_PRECISION
+	 */
+	public liquidationPrice(
+		targetMarket: Pick<UserPosition, 'marketIndex'>,
+		positionBaseSizeChange: BN = ZERO,
+		partial = false
+	): BN {
+		// solves formula for example calc below
+
+		/* example: assume BTC price is $40k (examine 10% up/down)
+			
+			if 10k deposit and levered 10x short BTC => BTC up $400 means:
+			1. higher base_asset_value (+$4k)
+			2. lower collateral (-$4k)
+			3. (10k - 4k)/(100k + 4k) => 6k/104k => .0576
+	
+			for 10x long, BTC down $400:
+			3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
+
+		const tc = this.getTotalCollateral();
+		const tpv = this.getTotalPositionValue();
+
+		const partialLev = 16;
+		const maintLev = 20;
+
+		const thisLev = partial ? new BN(partialLev) : new BN(maintLev);
+
+		// calculate the total position value ignoring any value from the target market of the trade
+		const totalCurrentPositionValueIgnoringTargetUSDC =
+			this.getTotalPositionValueExcludingMarket(targetMarket.marketIndex);
+
+		const currentMarketPosition =
+			this.getUserPosition(targetMarket.marketIndex) ||
+			this.getEmptyPosition(targetMarket.marketIndex);
+
+		const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
+
+		const proposedBaseAssetAmount = currentMarketPositionBaseSize.add(
+			positionBaseSizeChange
+		);
+
+		// calculate position for current market after trade
+		const proposedMarketPosition: UserPosition = {
+			marketIndex: targetMarket.marketIndex,
+			baseAssetAmount: proposedBaseAssetAmount,
+			lastCumulativeFundingRate:
+				currentMarketPosition.lastCumulativeFundingRate,
+			quoteAssetAmount: new BN(0),
+		};
+
+		const market = this.clearingHouse.getMarket(
+			proposedMarketPosition.marketIndex
+		);
+
+		const proposedMarketPositionValueUSDC = calculateBaseAssetValue(
+			market,
+			proposedMarketPosition
+		);
+
+		// total position value after trade
+		const targetTotalPositionValueUSDC =
+			totalCurrentPositionValueIgnoringTargetUSDC.add(
+				proposedMarketPositionValueUSDC
+			);
+
+		let totalFreeCollateralUSDC = tc.sub(
+			totalCurrentPositionValueIgnoringTargetUSDC
+				.mul(TEN_THOUSAND)
+				.div(this.getMaxLeverage('Maintenance'))
+		);
+
+		if (partial) {
+			totalFreeCollateralUSDC = tc.sub(
+				totalCurrentPositionValueIgnoringTargetUSDC
+					.mul(TEN_THOUSAND)
+					.div(this.getMaxLeverage('Partial'))
+			);
+		}
+
+		let priceDelt;
+		if (currentMarketPositionBaseSize.lt(ZERO)) {
+			priceDelt = tc
+				.mul(thisLev)
+				.sub(tpv)
+				.mul(PRICE_TO_QUOTE_PRECISION)
+				.div(thisLev.add(new BN(1)));
+		} else {
+			priceDelt = tc
+				.mul(thisLev)
+				.sub(tpv)
+				.mul(PRICE_TO_QUOTE_PRECISION)
+				.div(thisLev.sub(new BN(1)));
+		}
+
+		const currentPrice = calculateMarkPrice(
+			this.clearingHouse.getMarket(targetMarket.marketIndex)
+		);
+
+		// if the position value after the trade is less than total collateral, there is no liq price
+		if (
+			targetTotalPositionValueUSDC.lte(totalFreeCollateralUSDC) &&
+			proposedMarketPosition.baseAssetAmount.gt(ZERO)
+		) {
+			return new BN(-1);
+		}
+
+		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
+
+		const eatMargin2 = priceDelt
+			.mul(AMM_RESERVE_PRECISION)
+			.div(proposedBaseAssetAmount);
+
+		const liqPrice = currentPrice.sub(eatMargin2);
+		return liqPrice;
+	}
+
 	/**
 	 * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
 	 * @param positionMarketIndex
@@ -466,7 +616,9 @@ export class ClearingHouseUser {
 		positionMarketIndex: BN,
 		closeQuoteAmount: BN
 	): BN {
-		const currentPosition = this.getUserPosition(positionMarketIndex);
+		const currentPosition =
+			this.getUserPosition(positionMarketIndex) ||
+			this.getEmptyPosition(positionMarketIndex);
 
 		const closeBaseAmount = currentPosition.baseAssetAmount
 			.mul(closeQuoteAmount)
@@ -488,6 +640,21 @@ export class ClearingHouseUser {
 
 	/**
 	 * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+	 *
+	 * To Calculate Max Quote Available:
+	 *
+	 * Case 1: SameSide
+	 * 	=> Remaining quote to get to maxLeverage
+	 *
+	 * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+	 * 	=> Current opposite position x2 + remaining to get to maxLeverage
+	 *
+	 * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+	 * 	=> strictly reduce current position size
+	 *
+	 * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+	 * 	=> current position + remaining to get to maxLeverage
+	 *
 	 * @param marketIndex
 	 * @param tradeSide
 	 * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
@@ -498,32 +665,28 @@ export class ClearingHouseUser {
 		tradeSide: PositionDirection,
 		userMaxLeverageSetting: BN
 	): BN {
-		// inline function which get's the current position size on the opposite side of the target trade
-		const getOppositePositionValueUSDC = () => {
-			if (!currentPosition) return ZERO;
+		const currentPosition =
+			this.getUserPosition(targetMarketIndex) ||
+			this.getEmptyPosition(targetMarketIndex);
 
-			const side = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
+		const targetSide = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
 
-			if (side === 'long' && currentPosition?.baseAssetAmount.isNeg()) {
-				return this.getPositionValue(targetMarketIndex);
-			} else if (
-				side === 'short' &&
-				!currentPosition?.baseAssetAmount.isNeg()
-			) {
-				return this.getPositionValue(targetMarketIndex);
-			}
+		const currentPositionSide = currentPosition?.baseAssetAmount.isNeg()
+			? 'short'
+			: 'long';
 
-			return ZERO;
-		};
+		const targettingSameSide = !currentPosition
+			? true
+			: targetSide === currentPositionSide;
 
-		const currentPosition = this.getUserPosition(targetMarketIndex);
+		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
+		const oppositeSizeValueUSDC = targettingSameSide
+			? ZERO
+			: this.getPositionValue(targetMarketIndex);
 
 		// get current leverage
 		const currentLeverage = this.getLeverage();
 
-		// remaining leverage
-		// let remainingLeverage = userMaxLeverageSetting;
-
 		const remainingLeverage = BN.max(
 			userMaxLeverageSetting.sub(currentLeverage),
 			ZERO
@@ -537,10 +700,57 @@ export class ClearingHouseUser {
 			.mul(totalCollateral)
 			.div(TEN_THOUSAND);
 
-		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
-		const oppositeSizeValueUSDC = getOppositePositionValueUSDC();
+		if (userMaxLeverageSetting.sub(currentLeverage).gte(ZERO)) {
+			if (oppositeSizeValueUSDC.eq(ZERO)) {
+				// case 1 : Regular trade where current total position less than max, and no opposite position to account for
+				// do nothing
+			} else {
+				// case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
+				maxPositionSize = maxPositionSize.add(
+					oppositeSizeValueUSDC.mul(new BN(2))
+				);
+			}
+		} else {
+			// current leverage is greater than max leverage - can only reduce position size
 
-		maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC);
+			if (!targettingSameSide) {
+				const currentPositionQuoteSize =
+					this.getPositionValue(targetMarketIndex);
+
+				const currentTotalQuoteSize = currentLeverage
+					.mul(totalCollateral)
+					.div(TEN_THOUSAND);
+
+				const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(
+					currentPositionQuoteSize
+				);
+
+				const quoteValueOfMaxLeverage = userMaxLeverageSetting
+					.mul(totalCollateral)
+					.div(TEN_THOUSAND);
+
+				if (
+					otherPositionsTotalQuoteSize
+						.sub(currentPositionQuoteSize)
+						.gte(quoteValueOfMaxLeverage)
+				) {
+					// case 3: Can only reduce the current position because it will still be greater than max leverage
+
+					maxPositionSize = currentPositionQuoteSize;
+				} else {
+					// case 4: Can reduce the position, and then take extra remaining quote to get to max leverage
+
+					const allowedQuoteSizeAfterClosingCurrentPosition =
+						quoteValueOfMaxLeverage.sub(otherPositionsTotalQuoteSize);
+
+					maxPositionSize = currentPositionQuoteSize.add(
+						allowedQuoteSizeAfterClosingCurrentPosition
+					);
+				}
+			} else {
+				// do nothing if targetting same side
+			}
+		}
 
 		// subtract oneMillionth of maxPositionSize
 		// => to avoid rounding errors when taking max leverage
@@ -562,12 +772,16 @@ export class ClearingHouseUser {
 		tradeQuoteAmount: BN,
 		tradeSide: PositionDirection
 	): BN {
-		const currentPosition = this.getUserPosition(targetMarketIndex);
-		let currentPositionQuoteAmount = currentPosition.quoteAssetAmount;
+		const currentPosition =
+			this.getUserPosition(targetMarketIndex) ||
+			this.getEmptyPosition(targetMarketIndex);
+
+		let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex);
 
-		const currentSide = currentPosition.baseAssetAmount.isNeg()
-			? PositionDirection.SHORT
-			: PositionDirection.LONG;
+		const currentSide =
+			currentPosition && currentPosition.baseAssetAmount.isNeg()
+				? PositionDirection.SHORT
+				: PositionDirection.LONG;
 
 		if (currentSide === PositionDirection.SHORT)
 			currentPositionQuoteAmount = currentPositionQuoteAmount.neg();
@@ -582,11 +796,18 @@ export class ClearingHouseUser {
 		const totalPositionAfterTradeExcludingTargetMarket =
 			this.getTotalPositionValueExcludingMarket(targetMarketIndex);
 
-		return currentMarketPositionAfterTrade
-			.add(totalPositionAfterTradeExcludingTargetMarket)
-			.abs()
-			.mul(TEN_THOUSAND)
-			.div(this.getTotalCollateral());
+		const totalCollateral = this.getTotalCollateral();
+
+		if (totalCollateral.gt(ZERO)) {
+			const newLeverage = currentMarketPositionAfterTrade
+				.add(totalPositionAfterTradeExcludingTargetMarket)
+				.abs()
+				.mul(TEN_THOUSAND)
+				.div(totalCollateral);
+			return newLeverage;
+		} else {
+			return new BN(0);
+		}
 	}
 
 	/**
@@ -608,17 +829,13 @@ export class ClearingHouseUser {
 	 * @returns positionValue : Precision QUOTE_PRECISION
 	 */
 	private getTotalPositionValueExcludingMarket(marketToIgnore: BN): BN {
-		const currentMarketPosition = this.getUserPosition(marketToIgnore);
+		const currentMarketPosition =
+			this.getUserPosition(marketToIgnore) ||
+			this.getEmptyPosition(marketToIgnore);
 
 		let currentMarketPositionValueUSDC = ZERO;
 		if (currentMarketPosition) {
-			const market = this.clearingHouse.getMarket(
-				currentMarketPosition.marketIndex
-			);
-			currentMarketPositionValueUSDC = calculateBaseAssetValue(
-				market,
-				currentMarketPosition
-			);
+			currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
 		}
 
 		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);

package/src/constants/markets.ts

@@ -51,4 +51,11 @@ export const Markets: Market[] = [
 		devnetPythOracle: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
 		mainnetPythOracle: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
 	},
+	{
+		symbol: 'MATIC-PERP',
+		baseAssetSymbol: 'MATIC',
+		marketIndex: new BN(6),
+		devnetPythOracle: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
+		mainnetPythOracle: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
+	},
 ];

package/src/constants/numericConstants.ts

@@ -19,3 +19,6 @@ export const AMM_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^7
 export const PRICE_TO_QUOTE_PRECISION =
 	MARK_PRICE_PRECISION.div(QUOTE_PRECISION);
+export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =
+	AMM_RESERVE_PRECISION.mul(PEG_PRECISION).div(QUOTE_PRECISION); // 10^10
+

package/src/examples/makeTradeExample.ts

@@ -1,4 +1,5 @@
-import { BN, Provider, Wallet } from '@project-serum/anchor';
+import { BN, Provider } from '@project-serum/anchor';
+import {Wallet} from "..";
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {