@drift-labs/sdk 0.1.12 → 0.1.16

package/src/accounts/types.ts

@@ -16,6 +16,7 @@ import { EventEmitter } from 'events';
 export interface AccountSubscriber<T> {
 	data?: T;
 	subscribe(onChange: (data: T) => void): Promise<void>;
+	fetch(): Promise<void>;
 	unsubscribe(): void;
 }
 
@@ -54,7 +55,7 @@ export interface ClearingHouseAccountSubscriber {
 	subscribe(
 		optionalSubscriptions?: ClearingHouseAccountTypes[]
 	): Promise<boolean>;
-
+	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
 	getStateAccount(): StateAccount;
@@ -67,33 +68,6 @@ export interface ClearingHouseAccountSubscriber {
 	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
 }
 
-export interface HistoryAccountEvents {
-	fundingPaymentHistoryAccountUpdate: (
-		payload: FundingPaymentHistoryAccount
-	) => void;
-	fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
-	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
-	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
-	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
-	update: void;
-}
-
-export interface HistoryAccountSubscriber {
-	eventEmitter: StrictEventEmitter<EventEmitter, HistoryAccountEvents>;
-	isSubscribed: boolean;
-
-	subscribe(): Promise<boolean>;
-	unsubscribe(): Promise<void>;
-
-	getTradeHistoryAccount(): TradeHistoryAccount;
-	getDepositHistoryAccount(): DepositHistoryAccount;
-	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-	getCurveHistoryAccount(): CurveHistoryAccount;
-	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-}
-
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;
@@ -105,6 +79,7 @@ export interface UserAccountSubscriber {
 	isSubscribed: boolean;
 
 	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
 	getUserAccount(): UserAccount;

package/src/accounts/webSocketAccountSubscriber.ts

@@ -7,6 +7,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	accountName: string;
 	program: Program;
 	accountPublicKey: PublicKey;
+	onChange: (data: T) => void;
 
 	public constructor(
 		accountName: string,
@@ -19,20 +20,29 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
-		this.data = (await this.program.account[this.accountName].fetch(
-			this.accountPublicKey
-		)) as T;
-
-		onChange(this.data);
+		this.onChange = onChange;
+		await this.fetch();
 
 		this.program.account[this.accountName]
 			.subscribe(this.accountPublicKey, this.program.provider.opts.commitment)
 			.on('change', async (data: T) => {
 				this.data = data;
-				onChange(data);
+				this.onChange(data);
 			});
 	}
 
+	async fetch(): Promise<void> {
+		const newData = (await this.program.account[this.accountName].fetch(
+			this.accountPublicKey
+		)) as T;
+
+		// if data has changed trigger update
+		if (JSON.stringify(newData) !== JSON.stringify(this.data)) {
+			this.data = newData;
+			this.onChange(this.data);
+		}
+	}
+
 	unsubscribe(): Promise<void> {
 		return this.program.account[this.accountName].unsubscribe(
 			this.accountPublicKey

package/src/clearingHouse.ts

@@ -16,7 +16,6 @@ import {
 	PositionDirection,
 	TradeHistoryAccount,
 	UserAccount,
-	UserPositionsAccount,
 	Market,
 } from './types';
 import * as anchor from '@project-serum/anchor';
@@ -140,6 +139,13 @@ export class ClearingHouse {
 		]);
 	}
 
+	/**
+	 *	Forces the accountSubscriber to fetch account updates from rpc
+	 */
+	public async fetchAccounts(): Promise<void> {
+		await this.accountSubscriber.fetch();
+	}
+
 	/**
 	 * Unsubscribe from all currently subscribed state accounts
 	 */
@@ -454,7 +460,7 @@ export class ClearingHouse {
 		collateralAccountPublicKey: PublicKey
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const user: UserAccount = await this.program.account.user.fetch(
+		const user: any = await this.program.account.user.fetch(
 			userAccountPublicKey
 		);
 
@@ -659,7 +665,7 @@ export class ClearingHouse {
 		const liquidateeUserAccount: any = await this.program.account.user.fetch(
 			liquidateeUserAccountPublicKey
 		);
-		const liquidateePositions: UserPositionsAccount =
+		const liquidateePositions: any =
 			await this.program.account.userPositions.fetch(
 				liquidateeUserAccount.positions
 			);

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;
@@ -205,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);
 	}
@@ -226,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,
@@ -246,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];
 	}
 
 	/**
@@ -350,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
@@ -379,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 = {
@@ -412,9 +435,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 +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
@@ -466,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)
@@ -488,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
@@ -498,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
@@ -537,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);
+
+				const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(
+					currentPositionQuoteSize
+				);
 
-		maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC);
+				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 +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);
+
+		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 +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);
+		}
 	}
 
 	/**
@@ -608,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

@@ -51,4 +51,25 @@ export const Markets: Market[] = [
 		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',
+	},
+	{
+		symbol: 'DOT-PERP',
+		baseAssetSymbol: 'DOT',
+		marketIndex: new BN(8),
+		devnetPythOracle: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
+		mainnetPythOracle: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
+	},
 ];