@drift-labs/sdk 0.1.11 → 0.1.15

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';
@@ -22,6 +25,7 @@ import {
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
 	PositionDirection,
+	calculateTradeSlippage,
 } from '.';
 import { getUserAccountPublicKey } from './addresses';
 
@@ -67,6 +71,13 @@ export class ClearingHouseUser {
 		return this.isSubscribed;
 	}
 
+	/**
+	 *	Forces the accountSubscriber to fetch account updates from rpc
+	 */
+	public async fetchAccounts(): Promise<void> {
+		await this.accountSubscriber.fetch();
+	}
+
 	public async unsubscribe(): Promise<void> {
 		await this.accountSubscriber.unsubscribe();
 		this.isSubscribed = false;
@@ -81,23 +92,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;
@@ -145,30 +158,32 @@ export class ClearingHouseUser {
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedPNL(withFunding?: boolean): BN {
-		return this.getUserPositionsAccount().positions.reduce(
-			(pnl, marketPosition) => {
+	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
+		return this.getUserPositionsAccount()
+			.positions.filter((pos) =>
+				marketIndex ? pos.marketIndex === marketIndex : true
+			)
+			.reduce((pnl, marketPosition) => {
 				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
 				return pnl.add(
 					calculatePositionPNL(market, marketPosition, withFunding)
 				);
-			},
-			ZERO
-		);
+			}, ZERO);
 	}
 
 	/**
 	 * calculates unrealized funding payment pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedFundingPNL(): BN {
-		return this.getUserPositionsAccount().positions.reduce(
-			(pnl, marketPosition) => {
+	public getUnrealizedFundingPNL(marketIndex?: BN): BN {
+		return this.getUserPositionsAccount()
+			.positions.filter((pos) =>
+				marketIndex ? pos.marketIndex === marketIndex : true
+			)
+			.reduce((pnl, marketPosition) => {
 				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
 				return pnl.add(calculatePositionFundingPNL(market, marketPosition));
-			},
-			ZERO
-		);
+			}, ZERO);
 	}
 
 	/**
@@ -203,7 +218,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);
 	}
@@ -224,15 +240,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,
@@ -244,12 +262,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];
 	}
 
 	/**
@@ -348,7 +375,7 @@ export class ClearingHouseUser {
 	 * @param partial
 	 * @returns Precision : MARK_PRICE_PRECISION
 	 */
-	public liquidationPrice(
+	public liquidationPriceOld(
 		targetMarket: Pick<UserPosition, 'marketIndex'>,
 		positionBaseSizeChange: BN = ZERO,
 		partial = false
@@ -377,13 +404,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 = {
@@ -410,24 +435,36 @@ 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) && proposedMarketPosition.baseAssetAmount.gt(ZERO)) {
+		if (
+			targetTotalPositionValueUSDC.lte(totalFreeCollateralUSDC) &&
+			proposedMarketPosition.baseAssetAmount.gt(ZERO)
+		) {
 			return new BN(-1);
 		}
 
-		// proportion of proposed market position to overall position
-		// const marketProportion = proposedMarketPositionValueUSDC
-		// 	.mul(TEN_THOUSAND)
-		// 	.div(targetTotalPositionValueUSDC);
-
 		// get current margin ratio based on current collateral and proposed total position value
 		let marginRatio;
-		if (targetTotalPositionValueUSDC.eq(ZERO)) {
+		if (proposedMarketPositionValueUSDC.eq(ZERO)) {
 			marginRatio = BN_MAX;
 		} else {
 			marginRatio = totalCollateralUSDC
 				.mul(TEN_THOUSAND)
-				.div(targetTotalPositionValueUSDC);
+				.div(proposedMarketPositionValueUSDC);
 		}
 
 		let liqRatio = FULL_LIQUIDATION_RATIO;
@@ -438,29 +475,6 @@ export class ClearingHouseUser {
 		// sign of position in current market after the trade
 		const baseAssetSignIsNeg = proposedMarketPosition.baseAssetAmount.isNeg();
 
-		// console.log(
-		// 	convertToNumber(currentPrice),
-		// convertToNumber(liqRatio),
-		// convertToNumber(marginRatio),
-		// convertToNumber(marketProportion),
-		// );
-
-		// // if the user is long, then the liq price is the currentPrice multiplied by liqRatio/marginRatio (how many multiples lower does the current marginRatio have to go to reach the liqRatio), multiplied by the fraction of the proposed total position value that this market will take up
-		// if (!baseAssetSignIsNeg) {
-		// 	liqPrice = currentPrice
-		// 		.mul(liqRatio)
-		// 		.div(marginRatio)
-		// 		.mul(marketProportion)
-		// 		.div(TEN_THOUSAND);
-		// } else {
-		// 	// if the user is short, it's the reciprocal of the above
-		// 	liqPrice = currentPrice
-		// 		.mul(marginRatio)
-		// 		.div(liqRatio)
-		// 		.mul(TEN_THOUSAND)
-		// 		.div(marketProportion);
-		// }
-
 		let pctChange = marginRatio.abs().sub(liqRatio);
 		// if user is short, higher price is liq
 		if (baseAssetSignIsNeg) {
@@ -479,6 +493,143 @@ 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 (proposedBaseAssetAmount.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)));
+		}
+
+		let currentPrice;
+		if(positionBaseSizeChange.eq(ZERO)){
+			currentPrice = calculateMarkPrice(
+				this.clearingHouse.getMarket(targetMarket.marketIndex)
+			);
+		} else{
+			const direction = positionBaseSizeChange.gt(ZERO) ? PositionDirection.LONG : PositionDirection.SHORT;
+			currentPrice = calculateTradeSlippage(
+				direction,
+				positionBaseSizeChange.abs(),
+				this.clearingHouse.getMarket(targetMarket.marketIndex),
+				'base',
+			)[3]; // newPrice after swap
+		}
+		
+
+		// 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);
+
+		if(eatMargin2.gt(currentPrice)){
+			return new BN(-1);
+		}
+
+		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
@@ -489,7 +640,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)
@@ -511,6 +664,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
@@ -521,32 +689,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
@@ -560,10 +724,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
+
+			if (!targettingSameSide) {
+				const currentPositionQuoteSize =
+					this.getPositionValue(targetMarketIndex);
+
+				const currentTotalQuoteSize = currentLeverage
+					.mul(totalCollateral)
+					.div(TEN_THOUSAND);
 
-		maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC);
+				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
@@ -585,12 +796,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);
 
-		const currentSide = currentPosition.baseAssetAmount.isNeg()
-			? PositionDirection.SHORT
-			: PositionDirection.LONG;
+		let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex);
+
+		const currentSide =
+			currentPosition && currentPosition.baseAssetAmount.isNeg()
+				? PositionDirection.SHORT
+				: PositionDirection.LONG;
 
 		if (currentSide === PositionDirection.SHORT)
 			currentPositionQuoteAmount = currentPositionQuoteAmount.neg();
@@ -605,11 +820,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);
+		}
 	}
 
 	/**
@@ -631,17 +853,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

@@ -44,4 +44,25 @@ export const Markets: Market[] = [
 		devnetPythOracle: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
 		mainnetPythOracle: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
 	},
+	{
+		symbol: 'BNB-PERP',
+		baseAssetSymbol: 'BNB',
+		marketIndex: new BN(5),
+		devnetPythOracle: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
+		mainnetPythOracle: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
+	},
+	{
+		symbol: 'MATIC-PERP',
+		baseAssetSymbol: 'MATIC',
+		marketIndex: new BN(6),
+		devnetPythOracle: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
+		mainnetPythOracle: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
+	},
+	{
+		symbol: 'ATOM-PERP',
+		baseAssetSymbol: 'ATOM',
+		marketIndex: new BN(7),
+		devnetPythOracle: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
+		mainnetPythOracle: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
+	},
 ];

package/src/constants/numericConstants.ts

@@ -19,3 +19,5 @@ 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 {