@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/src/clearingHouseUser.ts

@@ -7,11 +7,11 @@ import {
 	MarginCategory,
 	Order,
 	UserAccount,
-	UserPosition,
+	PerpPosition,
 } from './types';
 import { calculateEntryPrice } from './math/position';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
 	TEN_THOUSAND,
@@ -20,7 +20,8 @@ import {
 	AMM_RESERVE_PRECISION,
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
-	BANK_WEIGHT_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	QUOTE_SPOT_MARKET_INDEX,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -28,21 +29,35 @@ import {
 	DataAndSlot,
 } from './accounts/types';
 import {
-	calculateMarkPrice,
+	calculateReservePrice,
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
+	calculateUnrealizedAssetWeight,
+	calculateMarketMarginRatio,
 	PositionDirection,
 	calculateTradeSlippage,
 	BN,
-	BankAccount,
+	SpotMarketAccount,
+	getTokenValue,
 } from '.';
-import { getTokenAmount } from './math/bankBalance';
+import {
+	getTokenAmount,
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+} from './math/spotBalance';
+import {
+	calculateBaseAssetValueWithOracle,
+	calculateWorstCaseBaseAssetAmount,
+} from './math/margin';
 import { OraclePriceData } from './oracles/types';
 import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
 import { PollingUserAccountSubscriber } from './accounts/pollingUserAccountSubscriber';
 import { WebSocketUserAccountSubscriber } from './accounts/webSocketUserAccountSubscriber';
-
+import {
+	getWorstCaseTokenAmounts,
+	isSpotPositionAvailable,
+} from './math/spotPosition';
 export class ClearingHouseUser {
 	clearingHouse: ClearingHouse;
 	userAccountPublicKey: PublicKey;
@@ -110,33 +125,42 @@ export class ClearingHouseUser {
 	 * @param marketIndex
 	 * @returns userPosition
 	 */
-	public getUserPosition(marketIndex: BN): UserPosition | undefined {
-		return this.getUserAccount().positions.find((position) =>
-			position.marketIndex.eq(marketIndex)
+	public getUserPosition(marketIndex: number): PerpPosition | undefined {
+		return this.getUserAccount().perpPositions.find(
+			(position) => position.marketIndex === marketIndex
 		);
 	}
 
-	public getEmptyPosition(marketIndex: BN): UserPosition {
+	public getEmptyPosition(marketIndex: number): PerpPosition {
 		return {
 			baseAssetAmount: ZERO,
+			remainderBaseAssetAmount: 0,
 			lastCumulativeFundingRate: ZERO,
 			marketIndex,
 			quoteAssetAmount: ZERO,
 			quoteEntryAmount: ZERO,
-			openOrders: ZERO,
-			unsettledPnl: ZERO,
+			openOrders: 0,
 			openBids: ZERO,
 			openAsks: ZERO,
+			settledPnl: ZERO,
+			lpShares: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 	}
 
+	public getClonedPosition(position: PerpPosition): PerpPosition {
+		const clonedPosition = Object.assign({}, position);
+		return clonedPosition;
+	}
+
 	/**
 	 * @param orderId
 	 * @returns Order
 	 */
-	public getOrder(orderId: BN): Order | undefined {
-		return this.getUserAccount().orders.find((order) =>
-			order.orderId.eq(orderId)
+	public getOrder(orderId: number): Order | undefined {
+		return this.getUserAccount().orders.find(
+			(order) => order.orderId === orderId
 		);
 	}
 
@@ -162,11 +186,115 @@ export class ClearingHouseUser {
 		return userAccountRPCResponse.value !== null;
 	}
 
+	/**
+	 * calculates the market position if the lp position was settled
+	 * @returns : the settled userPosition
+	 * @returns : the dust base asset amount (ie, < stepsize)
+	 * @returns : pnl from settle
+	 */
+	public getSettledLPPosition(marketIndex: number): [PerpPosition, BN, BN] {
+		const _position = this.getUserPosition(marketIndex);
+		const position = this.getClonedPosition(_position);
+
+		const market = this.clearingHouse.getPerpMarketAccount(
+			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;
+		}
+
+		function standardize(amount, stepsize) {
+			const remainder = amount.abs().mod(stepsize).mul(sign(amount));
+			const standardizedAmount = amount.sub(remainder);
+			return [standardizedAmount, remainder];
+		}
+
+		const [standardizedBaa, remainderBaa] = standardize(
+			deltaBaa,
+			market.amm.baseAssetAmountStepSize
+		);
+
+		position.remainderBaseAssetAmount += remainderBaa.toNumber();
+
+		if (
+			Math.abs(position.remainderBaseAssetAmount) >
+			market.amm.baseAssetAmountStepSize.toNumber()
+		) {
+			const [newStandardizedBaa, newRemainderBaa] = standardize(
+				position.remainderBaseAssetAmount,
+				market.amm.baseAssetAmountStepSize
+			);
+			position.baseAssetAmount =
+				position.baseAssetAmount.add(newStandardizedBaa);
+			position.remainderBaseAssetAmount = newRemainderBaa.toNumber();
+		}
+
+		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).add(deltaQaa);
+		} else {
+			newQuoteEntry = deltaQaa.sub(
+				deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs())
+			);
+			pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
+		}
+		position.quoteEntryAmount = newQuoteEntry;
+		position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+		position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
+
+		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, remainderBaa, pnl];
+	}
+
 	/**
 	 * calculates Buying Power = FC * MAX_LEVERAGE
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getBuyingPower(marketIndex: BN | number): BN {
+	public getBuyingPower(marketIndex: number): BN {
 		return this.getFreeCollateral()
 			.mul(this.getMaxLeverage(marketIndex, 'Initial'))
 			.div(TEN_THOUSAND);
@@ -183,82 +311,85 @@ export class ClearingHouseUser {
 		return freeCollateral.gte(ZERO) ? freeCollateral : ZERO;
 	}
 
-	public getInitialMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
-				);
-				return marginRequirement.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-						.mul(new BN(market.marginRatioInitial))
-						.div(MARGIN_PRECISION)
-				);
-			}, ZERO)
-			.add(this.getTotalLiability());
+	/**
+	 * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+	 */
+	public getMarginRequirement(
+		marginCategory: MarginCategory,
+		liquidationBuffer?: BN
+	): BN {
+		return this.getTotalPerpPositionValue(
+			marginCategory,
+			liquidationBuffer,
+			true
+		).add(
+			this.getSpotMarketLiabilityValue(
+				undefined,
+				marginCategory,
+				liquidationBuffer,
+				true
+			)
+		);
 	}
 
 	/**
-	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+	 * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getPartialMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
-				);
-				return marginRequirement.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-						.mul(new BN(market.marginRatioPartial))
-						.div(MARGIN_PRECISION)
-				);
-			}, ZERO)
-			.add(this.getTotalLiability());
+	public getInitialMarginRequirement(): BN {
+		return this.getMarginRequirement('Initial');
 	}
 
 	/**
-	 * calculates unrealized position price pnl
-	 * @returns : Precision QUOTE_PRECISION
+	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
-		return this.getUserAccount()
-			.positions.filter((pos) =>
-				marketIndex ? pos.marketIndex === marketIndex : true
-			)
-			.reduce((pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
-				);
-				return pnl.add(
-					calculatePositionPNL(
-						market,
-						marketPosition,
-						withFunding,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-				);
-			}, ZERO);
+	public getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN {
+		return this.getMarginRequirement('Maintenance', liquidationBuffer);
 	}
 
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnsettledPNL(marketIndex?: BN): BN {
+	public getUnrealizedPNL(
+		withFunding?: boolean,
+		marketIndex?: number,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
+		const quoteSpotMarket = this.clearingHouse.getQuoteSpotMarketAccount();
 		return this.getUserAccount()
-			.positions.filter((pos) =>
+			.perpPositions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
-			.reduce((pnl, marketPosition) => {
-				return pnl.add(marketPosition.unsettledPnl);
+			.reduce((unrealizedPnl, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
+				);
+				const oraclePriceData = this.getOracleDataForMarket(market.marketIndex);
+
+				let positionUnrealizedPnl = calculatePositionPNL(
+					market,
+					perpPosition,
+					withFunding,
+					oraclePriceData
+				);
+
+				if (withWeightMarginCategory !== undefined) {
+					if (positionUnrealizedPnl.gt(ZERO)) {
+						positionUnrealizedPnl = positionUnrealizedPnl
+							.mul(
+								calculateUnrealizedAssetWeight(
+									market,
+									quoteSpotMarket,
+									positionUnrealizedPnl,
+									withWeightMarginCategory,
+									oraclePriceData
+								)
+							)
+							.div(new BN(SPOT_MARKET_WEIGHT_PRECISION));
+					}
+				}
+
+				return unrealizedPnl.add(positionUnrealizedPnl);
 			}, ZERO);
 	}
 
@@ -266,163 +397,427 @@ export class ClearingHouseUser {
 	 * calculates unrealized funding payment pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedFundingPNL(marketIndex?: BN): BN {
+	public getUnrealizedFundingPNL(marketIndex?: number): BN {
 		return this.getUserAccount()
-			.positions.filter((pos) =>
+			.perpPositions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
-			.reduce((pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
+			.reduce((pnl, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
-				return pnl.add(calculatePositionFundingPNL(market, marketPosition));
+				return pnl.add(calculatePositionFundingPNL(market, perpPosition));
 			}, ZERO);
 	}
 
-	public getTotalLiability(): BN {
-		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+	public getSpotMarketLiabilityValue(
+		marketIndex?: number,
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN,
+		includeOpenOrders?: boolean
+	): BN {
+		return this.getUserAccount().spotPositions.reduce(
+			(totalLiabilityValue, spotPosition) => {
 				if (
-					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'deposit')
+					isSpotPositionAvailable(spotPosition) ||
+					(marketIndex !== undefined &&
+						spotPosition.marketIndex !== marketIndex)
 				) {
-					return totalAssetValue;
+					return totalLiabilityValue;
 				}
 
-				// Todo this needs to account for whether it's based on initial or maintenance requirements
-				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
-					bankBalance.bankIndex
-				);
+				const spotMarketAccount: SpotMarketAccount =
+					this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
 
-				const tokenAmount = getTokenAmount(
-					bankBalance.balance,
-					bankAccount,
-					bankBalance.balanceType
-				);
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialLiabilityWeight)
-						.div(BANK_WEIGHT_PRECISION)
-						.div(MARK_PRICE_PRECISION)
+				if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
+					if (isVariant(spotPosition.balanceType, 'borrow')) {
+						const tokenAmount = getTokenAmount(
+							spotPosition.balance,
+							spotMarketAccount,
+							spotPosition.balanceType
+						);
+
+						let weight = SPOT_MARKET_WEIGHT_PRECISION;
+						if (marginCategory === 'Initial') {
+							weight = BN.max(
+								weight,
+								new BN(this.getUserAccount().customMarginRatio)
+							);
+						}
+
+						const weightedTokenValue = tokenAmount
+							.mul(weight)
+							.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+						return totalLiabilityValue.add(weightedTokenValue);
+					} else {
+						return totalLiabilityValue;
+					}
+				}
+
+				const oraclePriceData = this.getOracleDataForSpotMarket(
+					spotPosition.marketIndex
 				);
+
+				if (!includeOpenOrders) {
+					if (isVariant(spotPosition.balanceType, 'borrow')) {
+						const tokenAmount = getTokenAmount(
+							spotPosition.balance,
+							spotMarketAccount,
+							spotPosition.balanceType
+						);
+						const liabilityValue = this.getSpotLiabilityValue(
+							tokenAmount,
+							oraclePriceData,
+							spotMarketAccount,
+							marginCategory,
+							liquidationBuffer
+						);
+						return totalLiabilityValue.add(liabilityValue);
+					} else {
+						return totalLiabilityValue;
+					}
+				}
+
+				const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] =
+					getWorstCaseTokenAmounts(
+						spotPosition,
+						spotMarketAccount,
+						this.getOracleDataForSpotMarket(spotPosition.marketIndex)
+					);
+
+				let newTotalLiabilityValue = totalLiabilityValue;
+				if (worstCaseTokenAmount.lt(ZERO)) {
+					const baseLiabilityValue = this.getSpotLiabilityValue(
+						worstCaseTokenAmount.abs(),
+						oraclePriceData,
+						spotMarketAccount,
+						marginCategory,
+						liquidationBuffer
+					);
+
+					newTotalLiabilityValue =
+						newTotalLiabilityValue.add(baseLiabilityValue);
+				}
+
+				if (worstCaseQuoteTokenAmount.lt(ZERO)) {
+					let weight = SPOT_MARKET_WEIGHT_PRECISION;
+					if (marginCategory === 'Initial') {
+						weight = BN.max(
+							weight,
+							new BN(this.getUserAccount().customMarginRatio)
+						);
+					}
+
+					const weightedTokenValue = worstCaseQuoteTokenAmount
+						.abs()
+						.mul(weight)
+						.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+					newTotalLiabilityValue =
+						newTotalLiabilityValue.add(weightedTokenValue);
+				}
+
+				return newTotalLiabilityValue;
 			},
 			ZERO
 		);
 	}
 
-	public getCollateralValue(bankIndex?: BN): BN {
-		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+	getSpotLiabilityValue(
+		tokenAmount: BN,
+		oraclePriceData: OraclePriceData,
+		spotMarketAccount: SpotMarketAccount,
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN
+	): BN {
+		let liabilityValue = getTokenValue(
+			tokenAmount,
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+
+		if (marginCategory !== undefined) {
+			let weight = calculateLiabilityWeight(
+				tokenAmount,
+				spotMarketAccount,
+				marginCategory
+			);
+
+			if (marginCategory === 'Initial') {
+				weight = BN.max(
+					weight,
+					new BN(this.getUserAccount().customMarginRatio)
+				);
+			}
+
+			if (liquidationBuffer !== undefined) {
+				weight = weight.add(liquidationBuffer);
+			}
+
+			liabilityValue = liabilityValue
+				.mul(weight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION);
+		}
+
+		return liabilityValue;
+	}
+
+	public getSpotMarketAssetValue(
+		marketIndex?: number,
+		marginCategory?: MarginCategory,
+		includeOpenOrders?: boolean
+	): BN {
+		return this.getUserAccount().spotPositions.reduce(
+			(totalAssetValue, spotPosition) => {
 				if (
-					bankBalance.balance.eq(ZERO) ||
-					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
+					isSpotPositionAvailable(spotPosition) ||
+					(marketIndex !== undefined &&
+						spotPosition.marketIndex !== marketIndex)
 				) {
 					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 spotMarketAccount: SpotMarketAccount =
+					this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
+
+				if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
+					if (isVariant(spotPosition.balanceType, 'deposit')) {
+						const tokenAmount = getTokenAmount(
+							spotPosition.balance,
+							spotMarketAccount,
+							spotPosition.balanceType
+						);
+
+						return totalAssetValue.add(tokenAmount);
+					} else {
+						return totalAssetValue;
+					}
+				}
 
-				let tokenAmount = getTokenAmount(
-					bankBalance.balance,
-					bankAccount,
-					bankBalance.balanceType
+				const oraclePriceData = this.getOracleDataForSpotMarket(
+					spotPosition.marketIndex
 				);
 
-				if (isVariant(bankBalance.balanceType, 'borrow')) {
-					tokenAmount = tokenAmount.mul(new BN(-1));
+				if (!includeOpenOrders) {
+					if (isVariant(spotPosition.balanceType, 'deposit')) {
+						const tokenAmount = getTokenAmount(
+							spotPosition.balance,
+							spotMarketAccount,
+							spotPosition.balanceType
+						);
+						const assetValue = this.getSpotAssetValue(
+							tokenAmount,
+							oraclePriceData,
+							spotMarketAccount,
+							marginCategory
+						);
+						return totalAssetValue.add(assetValue);
+					} else {
+						return totalAssetValue;
+					}
 				}
 
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.div(MARK_PRICE_PRECISION)
-				);
+				const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] =
+					getWorstCaseTokenAmounts(
+						spotPosition,
+						spotMarketAccount,
+						this.getOracleDataForSpotMarket(spotPosition.marketIndex)
+					);
+
+				let newTotalAssetValue = totalAssetValue;
+				if (worstCaseTokenAmount.gt(ZERO)) {
+					const baseAssetValue = this.getSpotAssetValue(
+						worstCaseTokenAmount,
+						oraclePriceData,
+						spotMarketAccount,
+						marginCategory
+					);
+
+					newTotalAssetValue = newTotalAssetValue.add(baseAssetValue);
+				}
+
+				if (worstCaseQuoteTokenAmount.gt(ZERO)) {
+					newTotalAssetValue = newTotalAssetValue.add(
+						worstCaseQuoteTokenAmount
+					);
+				}
+
+				return newTotalAssetValue;
 			},
 			ZERO
 		);
 	}
 
+	getSpotAssetValue(
+		tokenAmount: BN,
+		oraclePriceData: OraclePriceData,
+		spotMarketAccount: SpotMarketAccount,
+		marginCategory?: MarginCategory
+	): BN {
+		let assetValue = getTokenValue(
+			tokenAmount,
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+
+		if (marginCategory !== undefined) {
+			const weight = calculateAssetWeight(
+				tokenAmount,
+				spotMarketAccount,
+				marginCategory
+			);
+
+			assetValue = assetValue.mul(weight).div(SPOT_MARKET_WEIGHT_PRECISION);
+		}
+
+		return assetValue;
+	}
+
+	public getNetSpotMarketValue(withWeightMarginCategory?: MarginCategory): BN {
+		return this.getSpotMarketAssetValue(
+			undefined,
+			withWeightMarginCategory
+		).sub(
+			this.getSpotMarketLiabilityValue(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.getSpotMarketAssetValue(undefined, marginCategory, true).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 {
-		return this.getUserAccount().positions.reduce(
-			(positionValue, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
-				);
-				return positionValue.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+	getTotalPerpPositionValue(
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN,
+		includeOpenOrders?: boolean
+	): BN {
+		return this.getUserAccount().perpPositions.reduce(
+			(totalPerpValue, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
+
+				if (perpPosition.lpShares.gt(ZERO)) {
+					// is an lp
+					// clone so we dont mutate the position
+					perpPosition = this.getClonedPosition(perpPosition);
+
+					// settle position
+					const [settledPosition, dustBaa, _] = this.getSettledLPPosition(
+						market.marketIndex
+					);
+					perpPosition.baseAssetAmount =
+						settledPosition.baseAssetAmount.add(dustBaa);
+					perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+
+					// open orders
+					let openAsks;
+					if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
+						openAsks = market.amm.maxBaseAssetReserve
+							.sub(market.amm.baseAssetReserve)
+							.mul(perpPosition.lpShares)
+							.div(market.amm.sqrtK)
+							.mul(new BN(-1));
+					} else {
+						openAsks = ZERO;
+					}
+
+					let openBids;
+					if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
+						openBids = market.amm.baseAssetReserve
+							.sub(market.amm.minBaseAssetReserve)
+							.mul(perpPosition.lpShares)
+							.div(market.amm.sqrtK);
+					} else {
+						openBids = ZERO;
+					}
+
+					perpPosition.openAsks = perpPosition.openAsks.add(openAsks);
+					perpPosition.openBids = perpPosition.openBids.add(openBids);
+				}
+
+				let valuationPrice = this.getOracleDataForMarket(
+					market.marketIndex
+				).price;
+
+				if (isVariant(market.status, 'settlement')) {
+					valuationPrice = market.settlementPrice;
+				}
+
+				const baseAssetAmount = includeOpenOrders
+					? calculateWorstCaseBaseAssetAmount(perpPosition)
+					: perpPosition.baseAssetAmount;
+
+				let baseAssetValue = baseAssetAmount
+					.abs()
+					.mul(valuationPrice)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
+
+				if (marginCategory) {
+					let marginRatio = new BN(
+						calculateMarketMarginRatio(
+							market,
+							baseAssetAmount.abs(),
+							marginCategory
+						)
+					);
+
+					if (marginCategory === 'Initial') {
+						marginRatio = BN.max(
+							marginRatio,
+							new BN(this.getUserAccount().customMarginRatio)
+						);
+					}
+
+					if (liquidationBuffer !== undefined) {
+						marginRatio = marginRatio.add(liquidationBuffer);
+					}
+
+					baseAssetValue = baseAssetValue
+						.mul(marginRatio)
+						.div(MARGIN_PRECISION);
+				}
+
+				return totalPerpValue.add(baseAssetValue);
 			},
 			ZERO
 		);
 	}
 
 	/**
-	 * calculates position value from closing 100%
+	 * calculates position value in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getPositionValue(
-		marketIndex: BN,
+	public getPerpPositionValue(
+		marketIndex: number,
 		oraclePriceData: OraclePriceData
 	): BN {
 		const userPosition =
 			this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-		const market = this.clearingHouse.getMarketAccount(
+		const market = this.clearingHouse.getPerpMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateBaseAssetValueWithOracle(
+			market,
+			userPosition,
+			oraclePriceData
+		);
 	}
 
 	public getPositionSide(
-		currentPosition: Pick<UserPosition, 'baseAssetAmount'>
+		currentPosition: Pick<PerpPosition, 'baseAssetAmount'>
 	): PositionDirection | undefined {
 		if (currentPosition.baseAssetAmount.gt(ZERO)) {
 			return PositionDirection.LONG;
@@ -434,14 +829,17 @@ export class ClearingHouseUser {
 	}
 
 	/**
-	 * calculates average exit price for closing 100% of position
-	 * @returns : Precision MARK_PRICE_PRECISION
+	 * calculates average exit price (optionally for closing up to 100% of position)
+	 * @returns : Precision PRICE_PRECISION
 	 */
 	public getPositionEstimatedExitPriceAndPnl(
-		position: UserPosition,
-		amountToClose?: BN
+		position: PerpPosition,
+		amountToClose?: BN,
+		useAMMClose = false
 	): [BN, BN] {
-		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+		const market = this.clearingHouse.getPerpMarketAccount(
+			position.marketIndex
+		);
 
 		const entryPrice = calculateEntryPrice(position);
 
@@ -449,34 +847,44 @@ export class ClearingHouseUser {
 
 		if (amountToClose) {
 			if (amountToClose.eq(ZERO)) {
-				return [calculateMarkPrice(market, oraclePriceData), ZERO];
+				return [calculateReservePrice(market, oraclePriceData), ZERO];
 			}
 			position = {
 				baseAssetAmount: amountToClose,
 				lastCumulativeFundingRate: position.lastCumulativeFundingRate,
 				marketIndex: position.marketIndex,
 				quoteAssetAmount: position.quoteAssetAmount,
-			} as UserPosition;
+			} as PerpPosition;
 		}
 
-		const baseAssetValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
+		let baseAssetValue: BN;
+
+		if (useAMMClose) {
+			baseAssetValue = calculateBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		} else {
+			baseAssetValue = calculateBaseAssetValueWithOracle(
+				market,
+				position,
+				oraclePriceData
+			);
+		}
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return [ZERO, ZERO];
 		}
 
 		const exitPrice = baseAssetValue
 			.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.div(position.baseAssetAmount.abs());
 
 		const pnlPerBase = exitPrice.sub(entryPrice);
 		const pnl = pnlPerBase
 			.mul(position.baseAssetAmount)
-			.div(MARK_PRICE_PRECISION)
+			.div(PRICE_PRECISION)
 			.div(AMM_TO_QUOTE_PRECISION_RATIO);
 
 		return [exitPrice, pnl];
@@ -486,13 +894,31 @@ export class ClearingHouseUser {
 	 * calculates current user leverage across all positions
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getLeverage(): BN {
-		const totalCollateral = this.getTotalCollateral();
-		const totalPositionValue = this.getTotalPositionValue();
-		if (totalPositionValue.eq(ZERO) && totalCollateral.eq(ZERO)) {
+	public getLeverage(marginCategory?: MarginCategory): BN {
+		const totalLiabilityValue = this.getTotalPerpPositionValue(
+			marginCategory,
+			undefined,
+			true
+		).add(
+			this.getSpotMarketLiabilityValue(
+				undefined,
+				marginCategory,
+				undefined,
+				true
+			)
+		);
+
+		const totalAssetValue = this.getSpotMarketAssetValue(
+			undefined,
+			marginCategory,
+			true
+		).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+
+		if (totalAssetValue.eq(ZERO) && totalLiabilityValue.eq(ZERO)) {
 			return ZERO;
 		}
-		return totalPositionValue.mul(TEN_THOUSAND).div(totalCollateral);
+
+		return totalLiabilityValue.mul(TEN_THOUSAND).div(totalAssetValue);
 	}
 
 	/**
@@ -501,26 +927,17 @@ export class ClearingHouseUser {
 	 * @returns : Precision TEN_THOUSAND
 	 */
 	public getMaxLeverage(
-		marketIndex: BN | number,
+		marketIndex: number,
 		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 market = this.clearingHouse.getPerpMarketAccount(marketIndex);
+
+		const marginRatioCategory = calculateMarketMarginRatio(
+			market,
+			// worstCaseBaseAssetAmount.abs(),
+			ZERO, // todo
+			category
+		);
 		const maxLeverage = TEN_THOUSAND.mul(TEN_THOUSAND).div(
 			new BN(marginRatioCategory)
 		);
@@ -531,22 +948,46 @@ export class ClearingHouseUser {
 	 * calculates margin ratio: total collateral / |total position value|
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getMarginRatio(): BN {
-		const totalPositionValue = this.getTotalPositionValue();
+	public getMarginRatio(marginCategory?: MarginCategory): BN {
+		const totalLiabilityValue = this.getTotalPerpPositionValue(
+			marginCategory,
+			undefined,
+			true
+		).add(
+			this.getSpotMarketLiabilityValue(
+				undefined,
+				marginCategory,
+				undefined,
+				true
+			)
+		);
 
-		if (totalPositionValue.eq(ZERO)) {
+		if (totalLiabilityValue.eq(ZERO)) {
 			return BN_MAX;
 		}
 
-		return this.getTotalCollateral().mul(TEN_THOUSAND).div(totalPositionValue);
+		const totalAssetValue = this.getSpotMarketAssetValue(
+			undefined,
+			marginCategory,
+			true
+		).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+
+		return totalAssetValue.mul(TEN_THOUSAND).div(totalLiabilityValue);
 	}
 
-	public canBeLiquidated(): [boolean, BN] {
+	public canBeLiquidated(): boolean {
 		const totalCollateral = this.getTotalCollateral();
-		const partialMaintenanceRequirement = this.getPartialMarginRequirement();
-		const marginRatio = this.getMarginRatio();
-		const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
-		return [canLiquidate, marginRatio];
+
+		// if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
+		let liquidationBuffer = undefined;
+		if (this.getUserAccount().beingLiquidated) {
+			liquidationBuffer = new BN(
+				this.clearingHouse.getStateAccount().liquidationMarginBufferRatio
+			);
+		}
+		const maintenanceRequirement =
+			this.getMaintenanceMarginRequirement(liquidationBuffer);
+		return totalCollateral.lt(maintenanceRequirement);
 	}
 
 	/**
@@ -554,12 +995,12 @@ export class ClearingHouseUser {
 	 * @returns
 	 */
 	public needsToSettleFundingPayment(): boolean {
-		for (const userPosition of this.getUserAccount().positions) {
+		for (const userPosition of this.getUserAccount().perpPositions) {
 			if (userPosition.baseAssetAmount.eq(ZERO)) {
 				continue;
 			}
 
-			const market = this.clearingHouse.getMarketAccount(
+			const market = this.clearingHouse.getPerpMarketAccount(
 				userPosition.marketIndex
 			);
 			if (
@@ -580,15 +1021,14 @@ export class ClearingHouseUser {
 
 	/**
 	 * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
-	 * @param marketPosition
+	 * @param PerpPosition
 	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
 	 * @param partial
-	 * @returns Precision : MARK_PRICE_PRECISION
+	 * @returns Precision : PRICE_PRECISION
 	 */
 	public liquidationPrice(
-		marketPosition: Pick<UserPosition, 'marketIndex'>,
-		positionBaseSizeChange: BN = ZERO,
-		partial = false
+		perpPosition: Pick<PerpPosition, 'marketIndex'>,
+		positionBaseSizeChange: BN = ZERO
 	): BN {
 		// solves formula for example canBeLiquidated below
 
@@ -606,65 +1046,72 @@ export class ClearingHouseUser {
 
 		// calculate the total position value ignoring any value from the target market of the trade
 		const totalPositionValueExcludingTargetMarket =
-			this.getTotalPositionValueExcludingMarket(marketPosition.marketIndex);
+			this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex);
 
-		const currentMarketPosition =
-			this.getUserPosition(marketPosition.marketIndex) ||
-			this.getEmptyPosition(marketPosition.marketIndex);
+		const currentPerpPosition =
+			this.getUserPosition(perpPosition.marketIndex) ||
+			this.getEmptyPosition(perpPosition.marketIndex);
 
-		const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
+		const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
 
-		const proposedBaseAssetAmount = currentMarketPositionBaseSize.add(
+		const proposedBaseAssetAmount = currentPerpPositionBaseSize.add(
 			positionBaseSizeChange
 		);
 
 		// calculate position for current market after trade
-		const proposedMarketPosition: UserPosition = {
-			marketIndex: marketPosition.marketIndex,
+		const proposedPerpPosition: PerpPosition = {
+			marketIndex: perpPosition.marketIndex,
 			baseAssetAmount: proposedBaseAssetAmount,
-			lastCumulativeFundingRate:
-				currentMarketPosition.lastCumulativeFundingRate,
+			remainderBaseAssetAmount: 0,
 			quoteAssetAmount: new BN(0),
+			lastCumulativeFundingRate: ZERO,
 			quoteEntryAmount: new BN(0),
-			openOrders: new BN(0),
-			unsettledPnl: new BN(0),
+			openOrders: 0,
 			openBids: new BN(0),
 			openAsks: new BN(0),
+			settledPnl: ZERO,
+			lpShares: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
 
-		const market = this.clearingHouse.getMarketAccount(
-			proposedMarketPosition.marketIndex
+		const market = this.clearingHouse.getPerpMarketAccount(
+			proposedPerpPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateBaseAssetValue(
+		const proposedPerpPositionValue = calculateBaseAssetValueWithOracle(
 			market,
-			proposedMarketPosition,
+			proposedPerpPosition,
 			this.getOracleDataForMarket(market.marketIndex)
 		);
 
 		// total position value after trade
 		const totalPositionValueAfterTrade =
-			totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
+			totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
 
 		const marginRequirementExcludingTargetMarket =
-			this.getUserAccount().positions.reduce(
+			this.getUserAccount().perpPositions.reduce(
 				(totalMarginRequirement, position) => {
-					if (!position.marketIndex.eq(marketPosition.marketIndex)) {
-						const market = this.clearingHouse.getMarketAccount(
+					if (position.marketIndex !== perpPosition.marketIndex) {
+						const market = this.clearingHouse.getPerpMarketAccount(
 							position.marketIndex
 						);
-						const positionValue = calculateBaseAssetValue(
+						const positionValue = calculateBaseAssetValueWithOracle(
 							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(
@@ -683,18 +1130,22 @@ export class ClearingHouseUser {
 		// if the position value after the trade is less than free collateral, there is no liq price
 		if (
 			totalPositionValueAfterTrade.lte(freeCollateralExcludingTargetMarket) &&
-			proposedMarketPosition.baseAssetAmount.abs().gt(ZERO)
+			proposedPerpPosition.baseAssetAmount.abs().gt(ZERO)
 		) {
 			return new BN(-1);
 		}
 
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
-				proposedMarketPositionValue
+				proposedPerpPositionValue
 					.mul(
-						partial
-							? new BN(market.marginRatioPartial)
-							: new BN(market.marginRatioMaintenance)
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								proposedPerpPosition.baseAssetAmount.abs(),
+								'Maintenance'
+							)
+						)
 					)
 					.div(MARGIN_PRECISION)
 			);
@@ -702,9 +1153,10 @@ export class ClearingHouseUser {
 			marginRequirementAfterTrade
 		);
 
-		const marketMaxLeverage = partial
-			? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-			: this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+		const marketMaxLeverage = this.getMaxLeverage(
+			proposedPerpPosition.marketIndex,
+			'Maintenance'
+		);
 
 		let priceDelta;
 		if (proposedBaseAssetAmount.lt(ZERO)) {
@@ -725,9 +1177,9 @@ export class ClearingHouseUser {
 
 		let markPriceAfterTrade;
 		if (positionBaseSizeChange.eq(ZERO)) {
-			markPriceAfterTrade = calculateMarkPrice(
-				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
-				this.getOracleDataForMarket(marketPosition.marketIndex)
+			markPriceAfterTrade = calculateReservePrice(
+				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
+				this.getOracleDataForMarket(perpPosition.marketIndex)
 			);
 		} else {
 			const direction = positionBaseSizeChange.gt(ZERO)
@@ -736,9 +1188,9 @@ export class ClearingHouseUser {
 			markPriceAfterTrade = calculateTradeSlippage(
 				direction,
 				positionBaseSizeChange.abs(),
-				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
+				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
 				'base',
-				this.getOracleDataForMarket(marketPosition.marketIndex)
+				this.getOracleDataForMarket(perpPosition.marketIndex)
 			)[3]; // newPrice after swap
 		}
 
@@ -753,10 +1205,10 @@ export class ClearingHouseUser {
 	 * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
 	 * @param positionMarketIndex
 	 * @param closeQuoteAmount
-	 * @returns : Precision MARK_PRICE_PRECISION
+	 * @returns : Precision PRICE_PRECISION
 	 */
 	public liquidationPriceAfterClose(
-		positionMarketIndex: BN,
+		positionMarketIndex: number,
 		closeQuoteAmount: BN
 	): BN {
 		const currentPosition =
@@ -765,11 +1217,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 +1229,7 @@ export class ClearingHouseUser {
 			{
 				marketIndex: positionMarketIndex,
 			},
-			closeBaseAmount,
-			true
+			closeBaseAmount
 		);
 	}
 
@@ -804,7 +1255,7 @@ export class ClearingHouseUser {
 	 * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
 	 */
 	public getMaxTradeSizeUSDC(
-		targetMarketIndex: BN,
+		targetMarketIndex: number,
 		tradeSide: PositionDirection
 	): BN {
 		const currentPosition =
@@ -826,7 +1277,7 @@ export class ClearingHouseUser {
 		// 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 = targetingSameSide
 			? ZERO
-			: this.getPositionValue(targetMarketIndex, oracleData);
+			: this.getPerpPositionValue(targetMarketIndex, oracleData);
 
 		let maxPositionSize = this.getBuyingPower(targetMarketIndex);
 		if (maxPositionSize.gte(ZERO)) {
@@ -843,21 +1294,22 @@ export class ClearingHouseUser {
 			// current leverage is greater than max leverage - can only reduce position size
 
 			if (!targetingSameSide) {
-				const market = this.clearingHouse.getMarketAccount(targetMarketIndex);
-				const marketPositionValue = this.getPositionValue(
+				const market =
+					this.clearingHouse.getPerpMarketAccount(targetMarketIndex);
+				const perpPositionValue = this.getPerpPositionValue(
 					targetMarketIndex,
 					oracleData
 				);
 				const totalCollateral = this.getTotalCollateral();
 				const marginRequirement = this.getInitialMarginRequirement();
-				const marginFreedByClosing = marketPositionValue
+				const marginFreedByClosing = perpPositionValue
 					.mul(new BN(market.marginRatioInitial))
 					.div(MARGIN_PRECISION);
 				const marginRequirementAfterClosing =
 					marginRequirement.sub(marginFreedByClosing);
 
 				if (marginRequirementAfterClosing.gt(totalCollateral)) {
-					maxPositionSize = marketPositionValue;
+					maxPositionSize = perpPositionValue;
 				} else {
 					const freeCollateralAfterClose = totalCollateral.sub(
 						marginRequirementAfterClosing
@@ -865,7 +1317,7 @@ export class ClearingHouseUser {
 					const buyingPowerAfterClose = freeCollateralAfterClose
 						.mul(this.getMaxLeverage(targetMarketIndex))
 						.div(TEN_THOUSAND);
-					maxPositionSize = marketPositionValue.add(buyingPowerAfterClose);
+					maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
 				}
 			} else {
 				// do nothing if targetting same side
@@ -888,7 +1340,7 @@ export class ClearingHouseUser {
 	 * @returns leverageRatio : Precision TEN_THOUSAND
 	 */
 	public accountLeverageRatioAfterTrade(
-		targetMarketIndex: BN,
+		targetMarketIndex: number,
 		tradeQuoteAmount: BN,
 		tradeSide: PositionDirection
 	): BN {
@@ -898,7 +1350,7 @@ export class ClearingHouseUser {
 
 		const oracleData = this.getOracleDataForMarket(targetMarketIndex);
 
-		let currentPositionQuoteAmount = this.getPositionValue(
+		let currentPositionQuoteAmount = this.getPerpPositionValue(
 			targetMarketIndex,
 			oracleData
 		);
@@ -914,16 +1366,16 @@ export class ClearingHouseUser {
 		if (tradeSide === PositionDirection.SHORT)
 			tradeQuoteAmount = tradeQuoteAmount.neg();
 
-		const currentMarketPositionAfterTrade = currentPositionQuoteAmount
+		const currentPerpPositionAfterTrade = currentPositionQuoteAmount
 			.add(tradeQuoteAmount)
 			.abs();
 
 		const totalPositionAfterTradeExcludingTargetMarket =
-			this.getTotalPositionValueExcludingMarket(targetMarketIndex);
+			this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex);
 
 		const totalCollateral = this.getTotalCollateral();
 		if (totalCollateral.gt(ZERO)) {
-			const newLeverage = currentMarketPositionAfterTrade
+			const newLeverage = currentPerpPositionAfterTrade
 				.add(totalPositionAfterTradeExcludingTargetMarket)
 				.abs()
 				.mul(TEN_THOUSAND)
@@ -940,11 +1392,11 @@ export class ClearingHouseUser {
 	 * @returns feeForQuote : Precision QUOTE_PRECISION
 	 */
 	public calculateFeeForQuoteAmount(quoteAmount: BN): BN {
-		const feeStructure = this.clearingHouse.getStateAccount().feeStructure;
-
+		const feeTier =
+			this.clearingHouse.getStateAccount().perpFeeStructure.feeTiers[0];
 		return quoteAmount
-			.mul(feeStructure.feeNumerator)
-			.div(feeStructure.feeDenominator);
+			.mul(new BN(feeTier.feeNumerator))
+			.div(new BN(feeTier.feeDenominator));
 	}
 
 	/**
@@ -952,34 +1404,35 @@ export class ClearingHouseUser {
 	 * @param marketToIgnore
 	 * @returns positionValue : Precision QUOTE_PRECISION
 	 */
-	private getTotalPositionValueExcludingMarket(marketToIgnore: BN): BN {
-		const currentMarketPosition =
+	private getTotalPerpPositionValueExcludingMarket(marketToIgnore: number): BN {
+		const currentPerpPosition =
 			this.getUserPosition(marketToIgnore) ||
 			this.getEmptyPosition(marketToIgnore);
 
 		const oracleData = this.getOracleDataForMarket(marketToIgnore);
 
-		let currentMarketPositionValueUSDC = ZERO;
-		if (currentMarketPosition) {
-			currentMarketPositionValueUSDC = this.getPositionValue(
+		let currentPerpPositionValueUSDC = ZERO;
+		if (currentPerpPosition) {
+			currentPerpPositionValueUSDC = this.getPerpPositionValue(
 				marketToIgnore,
 				oracleData
 			);
 		}
 
-		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
+		return this.getTotalPerpPositionValue().sub(currentPerpPositionValueUSDC);
 	}
 
-	private getOracleDataForMarket(marketIndex: BN): OraclePriceData {
+	private getOracleDataForMarket(marketIndex: number): OraclePriceData {
 		const oracleKey =
-			this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
+			this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
 		const oracleData =
 			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
 
 		return oracleData;
 	}
-	private getOracleDataForBank(bankIndex: BN): OraclePriceData {
-		const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
+	private getOracleDataForSpotMarket(marketIndex: number): OraclePriceData {
+		const oracleKey =
+			this.clearingHouse.getSpotMarketAccount(marketIndex).oracle;
 
 		const oracleData =
 			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;