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

package/src/clearingHouseUser.ts

@@ -21,6 +21,7 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
 	BANK_WEIGHT_PRECISION,
+	BANK_BALANCE_PRECISION_EXP,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -32,17 +33,26 @@ import {
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
+	calculateUnrealizedAssetWeight,
+	calculateMarketMarginRatio,
 	PositionDirection,
 	calculateTradeSlippage,
 	BN,
 	BankAccount,
 } from '.';
-import { getTokenAmount } from './math/bankBalance';
+import {
+	getTokenAmount,
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+} from './math/bankBalance';
+import {
+	calculateMarginBaseAssetValue,
+	calculateWorstCaseBaseAssetAmount,
+} from './math/margin';
 import { OraclePriceData } from './oracles/types';
 import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
 import { PollingUserAccountSubscriber } from './accounts/pollingUserAccountSubscriber';
 import { WebSocketUserAccountSubscriber } from './accounts/webSocketUserAccountSubscriber';
-
 export class ClearingHouseUser {
 	clearingHouse: ClearingHouse;
 	userAccountPublicKey: PublicKey;
@@ -124,9 +134,13 @@ export class ClearingHouseUser {
 			quoteAssetAmount: ZERO,
 			quoteEntryAmount: ZERO,
 			openOrders: ZERO,
-			unsettledPnl: ZERO,
 			openBids: ZERO,
 			openAsks: ZERO,
+			realizedPnl: ZERO,
+			lpShares: ZERO,
+			lastFeePerLp: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 	}
 
@@ -162,6 +176,98 @@ export class ClearingHouseUser {
 		return userAccountRPCResponse.value !== null;
 	}
 
+	/**
+	 * calculates the market position if the lp position was settled
+	 * @returns : userPosition
+	 */
+	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN] {
+		const position = this.getUserPosition(marketIndex);
+		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+		const nShares = position.lpShares;
+
+		const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+			.sub(position.lastNetBaseAssetAmountPerLp)
+			.mul(nShares)
+			.div(AMM_RESERVE_PRECISION);
+		const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+			.sub(position.lastNetQuoteAssetAmountPerLp)
+			.mul(nShares)
+			.div(AMM_RESERVE_PRECISION);
+
+		function sign(v: BN) {
+			const sign = { true: new BN(1), false: new BN(-1) }[
+				v.gte(ZERO).toString()
+			];
+			return sign;
+		}
+
+		const remainder = deltaBaa
+			.abs()
+			.mod(market.amm.baseAssetAmountStepSize)
+			.mul(sign(deltaBaa));
+		const _standardizedBaa = deltaBaa.sub(remainder);
+
+		let remainderBaa;
+		if (_standardizedBaa.abs().gte(market.amm.baseAssetAmountStepSize)) {
+			remainderBaa = remainder;
+		} else {
+			remainderBaa = deltaBaa;
+		}
+		const standardizedBaa = deltaBaa.sub(remainderBaa);
+
+		const reaminderPerLP = remainderBaa.mul(AMM_RESERVE_PRECISION).div(nShares);
+
+		position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+		position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
+
+		position.lastNetBaseAssetAmountPerLp =
+			market.amm.marketPositionPerLp.baseAssetAmount.sub(reaminderPerLP);
+
+		let updateType;
+		if (position.baseAssetAmount.eq(ZERO)) {
+			updateType = 'open';
+		} else if (sign(position.baseAssetAmount).eq(sign(deltaBaa))) {
+			updateType = 'increase';
+		} else if (position.baseAssetAmount.abs().gt(deltaBaa.abs())) {
+			updateType = 'reduce';
+		} else if (position.baseAssetAmount.abs().eq(deltaBaa.abs())) {
+			updateType = 'close';
+		} else {
+			updateType = 'flip';
+		}
+
+		let newQuoteEntry;
+		let pnl;
+		if (updateType == 'open' || updateType == 'increase') {
+			newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
+			pnl = 0;
+		} else if (updateType == 'reduce' || updateType == 'close') {
+			newQuoteEntry = position.quoteEntryAmount.sub(
+				position.quoteEntryAmount
+					.mul(deltaBaa.abs())
+					.div(position.baseAssetAmount.abs())
+			);
+			pnl = position.quoteEntryAmount.sub(newQuoteEntry);
+		} else {
+			newQuoteEntry = deltaQaa.sub(
+				deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs())
+			);
+			pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
+		}
+		position.quoteEntryAmount = newQuoteEntry;
+
+		if (position.baseAssetAmount.gt(ZERO)) {
+			position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+		} else if (position.baseAssetAmount.lt(ZERO)) {
+			position.lastCumulativeFundingRate =
+				market.amm.cumulativeFundingRateShort;
+		} else {
+			position.lastCumulativeFundingRate = ZERO;
+		}
+
+		return [position, pnl];
+	}
+
 	/**
 	 * calculates Buying Power = FC * MAX_LEVERAGE
 	 * @returns : Precision QUOTE_PRECISION
@@ -184,81 +290,114 @@ export class ClearingHouseUser {
 	}
 
 	public getInitialMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
+		const postionMarginRequirement = this.getUserAccount().positions.reduce(
+			(marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return marginRequirement.add(
-					calculateBaseAssetValue(
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+				const marketMarginRatio = new BN(
+					calculateMarketMarginRatio(
 						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
+						worstCaseBaseAssetAmount.abs(),
+						'Initial'
 					)
-						.mul(new BN(market.marginRatioInitial))
-						.div(MARGIN_PRECISION)
 				);
-			}, ZERO)
-			.add(this.getTotalLiability());
+				return marginRequirement.add(
+					worstCaseAssetValue.mul(marketMarginRatio).div(MARGIN_PRECISION)
+				);
+			},
+			ZERO
+		);
+
+		const bankMarginRequirement = this.getBankLiabilityValue(
+			undefined,
+			'Initial'
+		);
+
+		return bankMarginRequirement.add(postionMarginRequirement);
 	}
 
 	/**
-	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getPartialMarginRequirement(): BN {
+	public getMaintenanceMarginRequirement(): BN {
 		return this.getUserAccount()
 			.positions.reduce((marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
 				return marginRequirement.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-						.mul(new BN(market.marginRatioPartial))
+					worstCaseAssetValue
+						.mul(
+							new BN(
+								calculateMarketMarginRatio(
+									market,
+									worstCaseBaseAssetAmount.abs(),
+									'Maintenance'
+								)
+							)
+						)
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
-			.add(this.getTotalLiability());
+			.add(this.getBankLiabilityValue(undefined, 'Maintenance'));
 	}
 
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
+	public getUnrealizedPNL(
+		withFunding?: boolean,
+		marketIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount()
 			.positions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
-			.reduce((pnl, marketPosition) => {
+			.reduce((unrealizedPnl, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return pnl.add(
-					calculatePositionPNL(
-						market,
-						marketPosition,
-						withFunding,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				let positionUnrealizedPnl = calculatePositionPNL(
+					market,
+					marketPosition,
+					withFunding,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
-			}, ZERO);
-	}
 
-	/**
-	 * calculates unrealized position price pnl
-	 * @returns : Precision QUOTE_PRECISION
-	 */
-	public getUnsettledPNL(marketIndex?: BN): BN {
-		return this.getUserAccount()
-			.positions.filter((pos) =>
-				marketIndex ? pos.marketIndex === marketIndex : true
-			)
-			.reduce((pnl, marketPosition) => {
-				return pnl.add(marketPosition.unsettledPnl);
+				if (withWeightMarginCategory !== undefined) {
+					if (positionUnrealizedPnl.gt(ZERO)) {
+						positionUnrealizedPnl = positionUnrealizedPnl
+							.mul(
+								calculateUnrealizedAssetWeight(
+									market,
+									positionUnrealizedPnl,
+									withWeightMarginCategory
+								)
+							)
+							.div(new BN(BANK_WEIGHT_PRECISION));
+					}
+				}
+
+				return unrealizedPnl.add(positionUnrealizedPnl);
 			}, ZERO);
 	}
 
@@ -279,14 +418,18 @@ export class ClearingHouseUser {
 			}, ZERO);
 	}
 
-	public getTotalLiability(): BN {
+	public getBankLiabilityValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+			(totalLiabilityValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'deposit')
+					isVariant(bankBalance.balanceType, 'deposit') ||
+					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
-					return totalAssetValue;
+					return totalLiabilityValue;
 				}
 
 				// Todo this needs to account for whether it's based on initial or maintenance requirements
@@ -299,23 +442,42 @@ export class ClearingHouseUser {
 					bankAccount,
 					bankBalance.balanceType
 				);
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialLiabilityWeight)
-						.div(BANK_WEIGHT_PRECISION)
-						.div(MARK_PRICE_PRECISION)
-				);
+
+				let liabilityValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateLiabilityWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					liabilityValue = liabilityValue
+						.mul(weight)
+						.div(BANK_WEIGHT_PRECISION);
+				}
+
+				return totalLiabilityValue.add(liabilityValue);
 			},
 			ZERO
 		);
 	}
 
-	public getCollateralValue(bankIndex?: BN): BN {
+	public getBankAssetValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
 			(totalAssetValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
+					isVariant(bankBalance.balanceType, 'borrow') ||
 					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
 					return totalAssetValue;
@@ -326,65 +488,53 @@ export class ClearingHouseUser {
 					bankBalance.bankIndex
 				);
 
-				let tokenAmount = getTokenAmount(
+				const tokenAmount = getTokenAmount(
 					bankBalance.balance,
 					bankAccount,
 					bankBalance.balanceType
 				);
 
-				if (isVariant(bankBalance.balanceType, 'borrow')) {
-					tokenAmount = tokenAmount.mul(new BN(-1));
+				let assetValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateAssetWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					assetValue = assetValue.mul(weight).div(BANK_WEIGHT_PRECISION);
 				}
 
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.div(MARK_PRICE_PRECISION)
-				);
+				return totalAssetValue.add(assetValue);
 			},
 			ZERO
 		);
 	}
 
+	public getNetBankValue(withWeightMarginCategory?: MarginCategory): BN {
+		return this.getBankAssetValue(undefined, withWeightMarginCategory).sub(
+			this.getBankLiabilityValue(undefined, withWeightMarginCategory)
+		);
+	}
+
 	/**
 	 * calculates TotalCollateral: collateral + unrealized pnl
-	 * TODO: rename to total equity (for perpetuals swaps)
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getTotalCollateral(): BN {
-		return this.getUserAccount()
-			.bankBalances.reduce((totalAssetValue, bankBalance) => {
-				if (
-					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'borrow')
-				) {
-					return totalAssetValue;
-				}
-
-				// Todo this needs to account for whether it's based on initial or maintenance requirements
-				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
-					bankBalance.bankIndex
-				);
-
-				const tokenAmount = getTokenAmount(
-					bankBalance.balance,
-					bankAccount,
-					bankBalance.balanceType
-				);
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialAssetWeight)
-						.div(BANK_WEIGHT_PRECISION)
-						.div(MARK_PRICE_PRECISION)
-				);
-			}, ZERO)
-			.add(this.getUnrealizedPNL(true))
-			.add(this.getUnsettledPNL());
+	public getTotalCollateral(marginCategory: MarginCategory = 'Initial'): BN {
+		return this.getBankAssetValue(undefined, marginCategory).add(
+			this.getUnrealizedPNL(true, undefined, marginCategory)
+		);
 	}
 
 	/**
-	 * calculates sum of position value across all positions
+	 * calculates sum of position value across all positions in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	getTotalPositionValue(): BN {
@@ -393,20 +543,20 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return positionValue.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				const posVal = calculateMarginBaseAssetValue(
+					market,
+					marketPosition,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
+
+				return positionValue.add(posVal);
 			},
 			ZERO
 		);
 	}
 
 	/**
-	 * calculates position value from closing 100%
+	 * calculates position value in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getPositionValue(
@@ -418,7 +568,7 @@ export class ClearingHouseUser {
 		const market = this.clearingHouse.getMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateMarginBaseAssetValue(market, userPosition, oraclePriceData);
 	}
 
 	public getPositionSide(
@@ -434,12 +584,13 @@ export class ClearingHouseUser {
 	}
 
 	/**
-	 * calculates average exit price for closing 100% of position
+	 * calculates average exit price (optionally for closing up to 100% of position)
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
 	public getPositionEstimatedExitPriceAndPnl(
 		position: UserPosition,
-		amountToClose?: BN
+		amountToClose?: BN,
+		useAMMClose = false
 	): [BN, BN] {
 		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
 
@@ -459,11 +610,21 @@ export class ClearingHouseUser {
 			} as UserPosition;
 		}
 
-		const baseAssetValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
+		let baseAssetValue: BN;
+
+		if (useAMMClose) {
+			baseAssetValue = calculateBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		} else {
+			baseAssetValue = calculateMarginBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		}
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return [ZERO, ZERO];
 		}
@@ -505,22 +666,13 @@ export class ClearingHouseUser {
 		category: MarginCategory = 'Initial'
 	): BN {
 		const market = this.clearingHouse.getMarketAccount(marketIndex);
-		let marginRatioCategory: number;
-
-		switch (category) {
-			case 'Initial':
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-			case 'Maintenance':
-				marginRatioCategory = market.marginRatioMaintenance;
-				break;
-			case 'Partial':
-				marginRatioCategory = market.marginRatioPartial;
-				break;
-			default:
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-		}
+
+		const marginRatioCategory = calculateMarketMarginRatio(
+			market,
+			// worstCaseBaseAssetAmount.abs(),
+			ZERO, // todo
+			category
+		);
 		const maxLeverage = TEN_THOUSAND.mul(TEN_THOUSAND).div(
 			new BN(marginRatioCategory)
 		);
@@ -543,7 +695,8 @@ export class ClearingHouseUser {
 
 	public canBeLiquidated(): [boolean, BN] {
 		const totalCollateral = this.getTotalCollateral();
-		const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+		const partialMaintenanceRequirement =
+			this.getMaintenanceMarginRequirement();
 		const marginRatio = this.getMarginRatio();
 		const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
 		return [canLiquidate, marginRatio];
@@ -587,8 +740,7 @@ export class ClearingHouseUser {
 	 */
 	public liquidationPrice(
 		marketPosition: Pick<UserPosition, 'marketIndex'>,
-		positionBaseSizeChange: BN = ZERO,
-		partial = false
+		positionBaseSizeChange: BN = ZERO
 	): BN {
 		// solves formula for example canBeLiquidated below
 
@@ -622,14 +774,17 @@ export class ClearingHouseUser {
 		const proposedMarketPosition: UserPosition = {
 			marketIndex: marketPosition.marketIndex,
 			baseAssetAmount: proposedBaseAssetAmount,
-			lastCumulativeFundingRate:
-				currentMarketPosition.lastCumulativeFundingRate,
 			quoteAssetAmount: new BN(0),
+			lastCumulativeFundingRate: ZERO,
 			quoteEntryAmount: new BN(0),
 			openOrders: new BN(0),
-			unsettledPnl: new BN(0),
 			openBids: new BN(0),
 			openAsks: new BN(0),
+			realizedPnl: ZERO,
+			lpShares: ZERO,
+			lastFeePerLp: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
@@ -638,7 +793,7 @@ export class ClearingHouseUser {
 			proposedMarketPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateBaseAssetValue(
+		const proposedMarketPositionValue = calculateMarginBaseAssetValue(
 			market,
 			proposedMarketPosition,
 			this.getOracleDataForMarket(market.marketIndex)
@@ -655,16 +810,20 @@ export class ClearingHouseUser {
 						const market = this.clearingHouse.getMarketAccount(
 							position.marketIndex
 						);
-						const positionValue = calculateBaseAssetValue(
+						const positionValue = calculateMarginBaseAssetValue(
 							market,
 							position,
 							this.getOracleDataForMarket(market.marketIndex)
 						);
 						const marketMarginRequirement = positionValue
 							.mul(
-								partial
-									? new BN(market.marginRatioPartial)
-									: new BN(market.marginRatioMaintenance)
+								new BN(
+									calculateMarketMarginRatio(
+										market,
+										position.baseAssetAmount.abs(),
+										'Maintenance'
+									)
+								)
 							)
 							.div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
@@ -692,9 +851,13 @@ export class ClearingHouseUser {
 			marginRequirementExcludingTargetMarket.add(
 				proposedMarketPositionValue
 					.mul(
-						partial
-							? new BN(market.marginRatioPartial)
-							: new BN(market.marginRatioMaintenance)
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								proposedMarketPosition.baseAssetAmount.abs(),
+								'Maintenance'
+							)
+						)
 					)
 					.div(MARGIN_PRECISION)
 			);
@@ -702,9 +865,10 @@ export class ClearingHouseUser {
 			marginRequirementAfterTrade
 		);
 
-		const marketMaxLeverage = partial
-			? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-			: this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+		const marketMaxLeverage = this.getMaxLeverage(
+			proposedMarketPosition.marketIndex,
+			'Maintenance'
+		);
 
 		let priceDelta;
 		if (proposedBaseAssetAmount.lt(ZERO)) {
@@ -765,11 +929,11 @@ export class ClearingHouseUser {
 
 		const closeBaseAmount = currentPosition.baseAssetAmount
 			.mul(closeQuoteAmount)
-			.div(currentPosition.quoteAssetAmount)
+			.div(currentPosition.quoteAssetAmount.abs())
 			.add(
 				currentPosition.baseAssetAmount
 					.mul(closeQuoteAmount)
-					.mod(currentPosition.quoteAssetAmount)
+					.mod(currentPosition.quoteAssetAmount.abs())
 			)
 			.neg();
 
@@ -777,8 +941,7 @@ export class ClearingHouseUser {
 			{
 				marketIndex: positionMarketIndex,
 			},
-			closeBaseAmount,
-			true
+			closeBaseAmount
 		);
 	}